// the one-minute version
Coreference resolution groups mentions that refer to the same discourse entity; entity linking connects a mention to a canonical knowledge-base entry. The pipeline must detect mentions, generate candidates, score compatibility, and form coherent clusters. Signals include agreement, syntax, recency, semantics, speaker, and world knowledge. Neural mention-ranking models compare each mention with candidate antecedents and a no-antecedent option. Entity linking combines mention context with candidate descriptions and popularity. Evaluation is difficult because mention boundaries, clustering, and annotation conventions interact, and gender or occupation stereotypes can create systematic harm.
Imagine arriving in a research lab with one deceptively simple request: build a system that can use language reliably. The room already contains datasets, model checkpoints, annotation manuals, benchmark tables, and confident demos. What it does not contain is a guarantee that everybody means the same thing by “use language.” Chapter 23 slows the room down. Its subject is Coreference Resolution and Entity Linking. Its job is to turn a broad topic into a sequence of explicit choices that a researcher can inspect, test, and defend.
Our running story will not begin with a library call. It begins with a user and an observable signal. “Jordan joined Mercury. They announced a launch.” Mention detection finds Jordan, Mercury, They, and a launch. Context may link “They” to Mercury if the organization announced the event, or to Jordan depending on discourse. Entity linking then decides whether Mercury is a company, planet, or another catalog entity. A good system keeps coreference confidence and knowledge-base confidence separate and supports NIL when no candidate fits. That miniature situation is enough to expose the chapter's full problem. Something in the world becomes data; the data is represented; alternatives are scored; a decision is decoded; and somebody must decide whether the result is good enough to use. The model is only one character in that story.
This companion follows the structure and main ideas of the official January 6, 2026 draft, but the wording, examples, diagrams, exercises, and explanations are original. It is written for a master's student who needs more than a list of terms: you should be able to derive the central mechanism, identify its assumptions, design a controlled experiment, and explain why a strong benchmark number may still fail to establish the claim you care about.
01 Begin with the problem, not the model
Mentions, anaphora, coreference clusters, mention detection, ranking architectures, entity linking, evaluation, Winograd-style cases, and gender bias. The important noun in that sentence is not the name of an architecture. It is the problem. A problem statement identifies an observable input, a desired output, the context legitimately available at decision time, and the cost of being wrong. Architecture selection comes later.
First principles are useful because language systems accumulate invisible conventions. A word boundary may be assumed rather than defined. A label may mix several human judgments. A train/test split may let the same speaker, document template, or memorized passage appear on both sides. An aggregate metric may give every error equal value even when deployment does not. If those choices remain hidden, a larger model can improve the number while leaving the real problem untouched.
For this chapter, ask four questions before reading any result. Representation: what exactly becomes a token, vector, frame, span, state, or candidate? Objective: which quantity is optimized, and is it the same behavior users need? Inference: how are candidates searched, constrained, ranked, or sampled? Evaluation: what held-out evidence would falsify the claim? These four questions create a map that survives changes in implementation fashion.
The loop used throughout this companion: make each hidden choice inspectable before trusting the final behavior.
02 The chapter's conceptual map
Read the following concepts as cooperating modules rather than vocabulary for an exam. Each owns a distinct responsibility. The interfaces between them are where assumptions become visible and where most serious debugging begins.
1. A mention is not the entity
Names, pronouns, descriptions, and sometimes omitted arguments can refer to the same real or discourse entity. Coreference clusters mentions; it does not automatically identify a real-world database record.
Build this idea from its contract. First name the observation available to the system; then name the representation that preserves the useful part of that observation; then identify the score, probability, constraint, or rule that distinguishes one candidate from another. Finally ask what output leaves this component and which later component is allowed to trust it. In coreference resolution and entity linking, these boundaries matter because a superficially correct final answer can be produced by the wrong evidence. A master's-level analysis therefore explains not just what the component returns, but what information it discards and which assumptions make the return value meaningful.
The idea also has an operational side. We would want examples where a mention is not the entity clearly helps, counterexamples where its assumptions break, an ablation that removes it, and a metric sensitive to the expected change. If removing it changes nothing, either the rest of the system learned a substitute or the evaluation never exercised the behavior. If it improves the average but harms a language, subgroup, input length, or rare class, the average is incomplete evidence. This is how we move from remembering a definition to making and defending a research claim.
Keep a mention is not the entity separate from mention detection sets the ceiling. They cooperate, but they answer different questions. Collapsing the two makes debugging impossible: an engineer sees only an incorrect output and cannot tell whether the representation was weak, the candidate set was incomplete, the scoring function preferred the wrong item, or the decoder violated a constraint. The chapter's larger lesson is to preserve these interfaces even when a neural model learns several stages jointly.
2. Mention detection sets the ceiling
If a mention is missed or its span is wrong, later linking cannot recover it. Some systems detect spans jointly with coreference; others begin from gold mentions in research, which produces an easier and less realistic task.
Build this idea from its contract. First name the observation available to the system; then name the representation that preserves the useful part of that observation; then identify the score, probability, constraint, or rule that distinguishes one candidate from another. Finally ask what output leaves this component and which later component is allowed to trust it. In coreference resolution and entity linking, these boundaries matter because a superficially correct final answer can be produced by the wrong evidence. A master's-level analysis therefore explains not just what the component returns, but what information it discards and which assumptions make the return value meaningful.
The idea also has an operational side. We would want examples where mention detection sets the ceiling clearly helps, counterexamples where its assumptions break, an ablation that removes it, and a metric sensitive to the expected change. If removing it changes nothing, either the rest of the system learned a substitute or the evaluation never exercised the behavior. If it improves the average but harms a language, subgroup, input length, or rare class, the average is incomplete evidence. This is how we move from remembering a definition to making and defending a research claim.
Keep mention detection sets the ceiling separate from mention ranking compares antecedents. They cooperate, but they answer different questions. Collapsing the two makes debugging impossible: an engineer sees only an incorrect output and cannot tell whether the representation was weak, the candidate set was incomplete, the scoring function preferred the wrong item, or the decoder violated a constraint. The chapter's larger lesson is to preserve these interfaces even when a neural model learns several stages jointly.
3. Mention ranking compares antecedents
For each new mention, score earlier spans plus a dummy option for starting a new entity. Pair features and contextual representations capture agreement, distance, syntax, and semantics. Cluster construction must keep decisions globally coherent.
Build this idea from its contract. First name the observation available to the system; then name the representation that preserves the useful part of that observation; then identify the score, probability, constraint, or rule that distinguishes one candidate from another. Finally ask what output leaves this component and which later component is allowed to trust it. In coreference resolution and entity linking, these boundaries matter because a superficially correct final answer can be produced by the wrong evidence. A master's-level analysis therefore explains not just what the component returns, but what information it discards and which assumptions make the return value meaningful.
The idea also has an operational side. We would want examples where mention ranking compares antecedents clearly helps, counterexamples where its assumptions break, an ablation that removes it, and a metric sensitive to the expected change. If removing it changes nothing, either the rest of the system learned a substitute or the evaluation never exercised the behavior. If it improves the average but harms a language, subgroup, input length, or rare class, the average is incomplete evidence. This is how we move from remembering a definition to making and defending a research claim.
Keep mention ranking compares antecedents separate from entity linking adds a catalog. They cooperate, but they answer different questions. Collapsing the two makes debugging impossible: an engineer sees only an incorrect output and cannot tell whether the representation was weak, the candidate set was incomplete, the scoring function preferred the wrong item, or the decoder violated a constraint. The chapter's larger lesson is to preserve these interfaces even when a neural model learns several stages jointly.
4. Entity linking adds a catalog
Candidate generation finds possible knowledge-base entries from aliases; disambiguation compares the local context and candidate description. NIL handling is essential when the correct entity is absent from the catalog.
Build this idea from its contract. First name the observation available to the system; then name the representation that preserves the useful part of that observation; then identify the score, probability, constraint, or rule that distinguishes one candidate from another. Finally ask what output leaves this component and which later component is allowed to trust it. In coreference resolution and entity linking, these boundaries matter because a superficially correct final answer can be produced by the wrong evidence. A master's-level analysis therefore explains not just what the component returns, but what information it discards and which assumptions make the return value meaningful.
The idea also has an operational side. We would want examples where entity linking adds a catalog clearly helps, counterexamples where its assumptions break, an ablation that removes it, and a metric sensitive to the expected change. If removing it changes nothing, either the rest of the system learned a substitute or the evaluation never exercised the behavior. If it improves the average but harms a language, subgroup, input length, or rare class, the average is incomplete evidence. This is how we move from remembering a definition to making and defending a research claim.
Keep entity linking adds a catalog separate from bias appears in ambiguous links. They cooperate, but they answer different questions. Collapsing the two makes debugging impossible: an engineer sees only an incorrect output and cannot tell whether the representation was weak, the candidate set was incomplete, the scoring function preferred the wrong item, or the decoder violated a constraint. The chapter's larger lesson is to preserve these interfaces even when a neural model learns several stages jointly.
5. Bias appears in ambiguous links
Models may use occupational or gender stereotypes to resolve pronouns, producing different decisions for otherwise parallel sentences. Balanced evaluation and counterfactual tests expose these shortcuts.
Build this idea from its contract. First name the observation available to the system; then name the representation that preserves the useful part of that observation; then identify the score, probability, constraint, or rule that distinguishes one candidate from another. Finally ask what output leaves this component and which later component is allowed to trust it. In coreference resolution and entity linking, these boundaries matter because a superficially correct final answer can be produced by the wrong evidence. A master's-level analysis therefore explains not just what the component returns, but what information it discards and which assumptions make the return value meaningful.
The idea also has an operational side. We would want examples where bias appears in ambiguous links clearly helps, counterexamples where its assumptions break, an ablation that removes it, and a metric sensitive to the expected change. If removing it changes nothing, either the rest of the system learned a substitute or the evaluation never exercised the behavior. If it improves the average but harms a language, subgroup, input length, or rare class, the average is incomplete evidence. This is how we move from remembering a definition to making and defending a research claim.
Keep bias appears in ambiguous links separate from a mention is not the entity. They cooperate, but they answer different questions. Collapsing the two makes debugging impossible: an engineer sees only an incorrect output and cannot tell whether the representation was weak, the candidate set was incomplete, the scoring function preferred the wrong item, or the decoder violated a constraint. The chapter's larger lesson is to preserve these interfaces even when a neural model learns several stages jointly.
03 Derive the core mechanism carefully
Theory is useful when every symbol has an operational meaning. Do not memorize an equation before identifying what produces each term, which terms are observed, which are learned, and which approximation makes computation possible.
Now derive the system around the relationship. Start with the smallest legal input and write down its shape or structure. Enumerate the candidate outputs. Calculate or reason through one score by hand. Check normalization or structural constraints. Then change one input feature and predict the direction of the output change before executing code. This procedure catches sign errors, leaked context, illegal transitions, and confused units far earlier than end-to-end benchmarking.
Next distinguish estimation from decision. A model may estimate probabilities, similarities, alignments, or scores. A decoder, threshold, search algorithm, or policy turns them into a discrete output. The best estimator under log loss may not produce the best operational decision under asymmetric costs. Conversely, a clever decoder can hide a weak model on one benchmark while failing when the candidate distribution changes.
Finally distinguish training objective from evaluation metric. We choose differentiable losses because gradient-based optimization needs them; we choose evaluation measures because people need evidence about behavior. The two should be related but need not be identical. When they diverge, state the reason and test whether improvement in the surrogate actually predicts improvement in the target behavior.
04 A worked story from input to evidence
Linking a person, company, and pronoun
“Jordan joined Mercury. They announced a launch.” Mention detection finds Jordan, Mercury, They, and a launch. Context may link “They” to Mercury if the organization announced the event, or to Jordan depending on discourse. Entity linking then decides whether Mercury is a company, planet, or another catalog entity. A good system keeps coreference confidence and knowledge-base confidence separate and supports NIL when no candidate fits.
Stage 1 — define the observation. Record what the system truly receives at decision time. Do not quietly add future text, a gold annotation, a clean transcript, a manually selected passage, or metadata unavailable in production. This stage protects the validity of everything after it.
Stage 2 — construct the representation. Choose units that preserve the distinctions the task needs while remaining learnable from available data. Document normalization, vocabulary, missing values, masking, and alignment. Save enough information to map predictions back to the original input.
Stage 3 — produce candidates and scores. The model turns evidence into alternatives. Inspect at least the winner, a plausible runner-up, and an obviously wrong candidate. Their score differences reveal whether the model has a robust preference or won by a tiny, unstable margin.
Stage 4 — apply constraints and policy. A legal sequence, supported citation, safe action, or valid structure may require rules beyond the learned score. This is also where uncertainty becomes an abstention, clarification, escalation, or request for more evidence rather than a forced guess.
Stage 5 — evaluate at several levels. Component metrics localize faults; end-to-end metrics measure user-visible behavior. Use both. A correct final result can conceal a broken intermediate stage, and a strong component can be neutralized by a bad downstream policy.
Stage 6 — perform error analysis. Group failures by mechanism instead of collecting anecdotes. Look for length, frequency, language, subgroup, domain, noise, ambiguity, and annotation effects. A model improvement becomes scientifically convincing when it fixes the predicted category without creating an unreported regression elsewhere.
05 What usually goes wrong
The following traps are not footnotes. They are common ways a technically correct implementation produces a misleading research conclusion or unsafe product behavior.
common catches & gotchas
- Evaluating with gold mentions while deployment must detect them. The visible symptom is a result that may look plausible on ordinary examples while failing when this assumption is stressed. The likely cause is that training or evaluation rewarded a shortcut. Correct it by adding a targeted counterexample, measuring this failure separately, and tracing the decision back to its source evidence before changing model size.
- Forcing every name to a popular knowledge-base entity. The visible symptom is a result that may look plausible on ordinary examples while failing when this assumption is stressed. The likely cause is that training or evaluation rewarded a shortcut. Correct it by adding a targeted counterexample, measuring this failure separately, and tracing the decision back to its source evidence before changing model size.
- Using agreement rules that exclude singular they or diverse naming conventions. The visible symptom is a result that may look plausible on ordinary examples while failing when this assumption is stressed. The likely cause is that training or evaluation rewarded a shortcut. Correct it by adding a targeted counterexample, measuring this failure separately, and tracing the decision back to its source evidence before changing model size.
- Scoring only pair decisions rather than cluster quality. The visible symptom is a result that may look plausible on ordinary examples while failing when this assumption is stressed. The likely cause is that training or evaluation rewarded a shortcut. Correct it by adding a targeted counterexample, measuring this failure separately, and tracing the decision back to its source evidence before changing model size.
- Treating Winograd-style success as broad proof of commonsense reasoning. The visible symptom is a result that may look plausible on ordinary examples while failing when this assumption is stressed. The likely cause is that training or evaluation rewarded a shortcut. Correct it by adding a targeted counterexample, measuring this failure separately, and tracing the decision back to its source evidence before changing model size.
Notice the shared pattern. Each failure collapses two levels that should remain separate: fluent versus factual, score versus decision, token versus word, correlation versus cause, training distribution versus deployment population, or average quality versus unequal impact. The repair is to restore the missing boundary and measure it directly.
06 Evaluation for a master's-level study
A publishable evaluation begins with a claim table. For every claim, list the dataset slice, metric, baseline, ablation, uncertainty estimate, and known confounder. If the claim is “method A represents long context better,” a single overall accuracy score is insufficient. We need performance by length, a matched-compute baseline, a test that truly requires distant evidence, and an ablation showing the responsible component.
Intrinsic evidence
Does the component optimize or predict what it was designed to model? Useful for fast iteration, but not a substitute for task success.
Extrinsic evidence
Does the representation or model improve a downstream task under a controlled comparison?
Behavioral evidence
Do targeted minimal pairs and adversarial cases show the expected capability rather than a shortcut?
Operational evidence
Are latency, memory, cost, calibration, safety, and subgroup behavior acceptable in the intended environment?
Use a development set for model and threshold choices, then touch the final test set only after the design is fixed. Report variance across seeds when training instability is material. Use grouped or temporal splits when examples share authors, speakers, templates, or evolving events. Deduplicate before splitting. Document preprocessing and evaluate the exact exported pipeline, not an ideal notebook version.
Error analysis should be quantitative enough to change a decision. Sample errors from defined buckets, have more than one reviewer when judgment is subjective, and record disagreement. A confusion matrix, retrieval audit, alignment backtrace, span-boundary table, or per-condition curve is often more actionable than another aggregate benchmark.
07 Study lab: turn the chapter into evidence
These exercises are designed as small research loops. Completing them produces artifacts you can inspect—a derivation, implementation, controlled comparison, and error taxonomy—rather than a vague feeling of familiarity.
01 · Annotate mentions and clusters in a short article.
Write the hypothesis before running the exercise. Record the input, expected behavior, metric, and one failure case. Afterward, explain whether the evidence supports the hypothesis and what alternative explanation remains.
02 · Build candidate antecedents with a no-link option.
Write the hypothesis before running the exercise. Record the input, expected behavior, metric, and one failure case. Afterward, explain whether the evidence supports the hypothesis and what alternative explanation remains.
03 · Separate mention-detection, linking, and clustering errors.
Write the hypothesis before running the exercise. Record the input, expected behavior, metric, and one failure case. Afterward, explain whether the evidence supports the hypothesis and what alternative explanation remains.
04 · Create NIL examples for entity linking.
Write the hypothesis before running the exercise. Record the input, expected behavior, metric, and one failure case. Afterward, explain whether the evidence supports the hypothesis and what alternative explanation remains.
05 · Run counterfactual gender and occupation swaps.
Write the hypothesis before running the exercise. Record the input, expected behavior, metric, and one failure case. Afterward, explain whether the evidence supports the hypothesis and what alternative explanation remains.
For an assignment or dissertation notebook, keep a short experiment ledger. Include the question, exact data snapshot, preprocessing hash, model and decoding configuration, random seed, hardware, metric implementation, result, and interpretation. Separate the number you observed from the explanation you infer. That distinction is one of the most valuable habits a master's program can teach.
08 Oral-exam questions
Coreference versus entity linking?
Coreference connects mentions within discourse; entity linking maps a mention to an external canonical entity. A strong answer should also state the boundary: which data, task, and assumptions make the claim true, and what observation would cause us to revise it.
What is an antecedent?
An earlier mention that a later anaphoric expression refers back to, though some references are not simple backward links. A strong answer should also state the boundary: which data, task, and assumptions make the claim true, and what observation would cause us to revise it.
Why are coreference metrics complicated?
They reward different aspects of cluster overlap, so systems usually report several metrics rather than one definitive score. A strong answer should also state the boundary: which data, task, and assumptions make the claim true, and what observation would cause us to revise it.
09 Complete chapter summary
Coreference resolution groups mentions that refer to the same discourse entity; entity linking connects a mention to a canonical knowledge-base entry. The pipeline must detect mentions, generate candidates, score compatibility, and form coherent clusters. Signals include agreement, syntax, recency, semantics, speaker, and world knowledge. Neural mention-ranking models compare each mention with candidate antecedents and a no-antecedent option. Entity linking combines mention context with candidate descriptions and popularity. Evaluation is difficult because mention boundaries, clustering, and annotation conventions interact, and gender or occupation stereotypes can create systematic harm.
The deeper story is the boundary between a model and a trustworthy language system. Mentions, anaphora, coreference clusters, mention detection, ranking architectures, entity linking, evaluation, Winograd-style cases, and gender bias. Each topic contributes one part of a larger reasoning chain. Representations determine what distinctions are even available. Objectives determine which behavior training rewards. Inference converts scores into a constrained output. Evaluation determines which claim survives contact with held-out evidence. Data connects all four and can quietly invalidate all four through leakage, poor coverage, inconsistent annotation, or historical bias.
- Mentions, discourse entities, and knowledge-base entities are distinct layers.
- Mention detection limits downstream recall.
- Ranking balances antecedent evidence with starting a new entity.
- NIL is a necessary entity-linking outcome.
- Bias testing belongs in ambiguous-reference evaluation.
Do not leave the chapter with only names of architectures or metrics. Leave with a method: define the task at the grain of the real decision; trace one example from raw input to final output; derive the central computation; preserve uncertainty and provenance; compare against a simple baseline; ablate the claimed contribution; inspect failures by mechanism; and state exactly where the evidence stops. That method will remain useful when today’s architecture is replaced.