Imagine trying to extract medical symptoms from the clinical note: "The patient experienced dark and bloody stool."
A human reader easily identifies two distinct clinical entities here: dark stool and bloody stool. While "bloody stool" forms a continuous block of text, "dark stool" is fragmented—split across the sentence and interrupted by the phrase "and bloody".
This is the core challenge of discontinuous entity recognition. In specialized domains like biomedicine, financial reporting, and literature, semantic units are frequently interrupted by modifiers, coordinate structures, or parenthetical clauses. Extracting them accurately requires moving past one of the oldest assumptions in Natural Language Processing: that an entity must be a continuous span of text.
The Contiguity Trap
Traditional Named Entity Recognition (NER) systems rely heavily on sequence labeling frameworks, such as the BIO (Beginning, Inside, Outside) tagging scheme. As noted by Beatrice Alex et al. in Recognising Nested Named Entities in Biomedical Text, these sequential approaches assume a strict linear continuity. When an entity is split across non-adjacent tokens, standard sequence models face a dilemma: they must either treat the fragments as entirely separate entities or expand the boundary to include the intervening words, introducing noise and reducing precision.
Even advanced span-based models, which evaluate entire phrases at once rather than token-by-token, fall into this trap. As Meizhi Ju et al. observe in A Neural Layered Model for Nested Named Entity Recognition, standard span extraction architectures are structurally bounded by a single start and end index. They lack a native mechanism to "skip" unrelated words, making them fundamentally ill-suited for capturing distributed semantic units.
To solve this, researchers have developed three primary paradigms that allow models to look across textual gaps and stitch fragmented entities back together.
Mechanism 1: Fragment Relation and Pointer Chains
One intuitive way to handle discontinuous entities is to break the problem into two steps: first, identify all potential entity fragments in a sentence, and second, predict which fragments belong together.
Fei Li 0021 et al. formalize this in A Span-Based Model for Joint Overlapped and Discontinuous Named Entity Recognition by reframing entity extraction as a fragment-relation task. The model enumerates text spans and uses a dependency-guided graph network to predict specific link types—such as succession or overlap—between distant fragments. If the model detects a "succession" link between "dark" and "stool", it safely assembles them into a single discontinuous entity.
[dark] <--- succession --- [and bloody] --- [stool]
| ^
+--------------------------------------------+
A closely related strategy uses token-level pointer chains within a relational grid. In USSA: A Unified Table Filling Scheme for Structured Sentiment Analysis, the authors employ a 2D table-filling scheme where the model learns to predict the next token of an entity, regardless of where it appears in the sentence. By encoding these next-word relations in a dedicated region of a relation matrix, the system can stitch together split phrases into a single coherent structure, effectively tracing a path through the intervening text.
Mechanism 2: Structural Graphs and Gap Modeling
Instead of treating the text as a flat sequence and linking fragments post-hoc, another approach builds the possibility of "gaps" directly into the model's structural representation of the sentence.
Aldrian Obaja Muis et al. pioneer this in Learning to Recognize Discontiguous Entities by introducing a hypergraph architecture that utilizes specialized gap nodes. These nodes explicitly represent and assign parameters to the words occurring between the pieces of a split entity. By assigning a structural identity to the gap itself, the hypergraph can maintain the overarching identity of a single entity across non-adjacent segments, preventing the fragmentation that typically degrades linear-chain models.
Similarly, Zhanming Jie et al. address non-contiguous concepts in Dependency-based Hybrid Trees for Semantic Parsing. By shifting from constituency-based representations to dependency-based hybrid trees, their framework models semantic units as latent dependencies between words. This allows the system to naturally capture meaning when a single concept is distributed across non-adjacent words, bypassing the rigid boundaries of standard text spans.
Mechanism 3: Generative Index Sequences
With the rise of sequence-to-sequence (Seq2Seq) architectures, researchers realized they could bypass the constraints of tagging grids and structural graphs altogether by changing how the target output is formatted.
In A Unified Generative Framework for Various NER Subtasks, Hang Yan et al. demonstrate that an autoregressive decoder can naturally handle flat, nested, and discontinuous entities using a single unified target format. Instead of generating text tokens, the model uses a pointer mechanism to generate a sequence of start and end index pairs.
For a continuous entity, the model outputs a single pair: [start, end, Label]. For a discontinuous entity, it simply concatenates multiple index pairs before the category label: [start1, end1, start2, end2, Label]. This flexible target format allows the model to leverage the full contextual awareness of a transformer decoder to group non-contiguous spans without needing specialized, multi-stage tagging architectures.
Summary
Discontinuous entity recognition shifts the paradigm of information extraction from simple boundary detection to a more sophisticated problem of semantic assembly. Whether by predicting relations between isolated fragments (Li et al., 2021), explicitly modeling structural gaps (Muis et al., 2016), or generating arbitrary index sequences (Yan et al., 2021), these techniques allow modern NLP systems to faithfully reconstruct the non-linear ways humans express ideas.