AMR Parsing

AMR graphs represent words as concept nodes rather than lexical tokens. This abstraction normalizes morphological variations (e.g., 'destroy' and 'destruction' map to the same node) and synonyms into a unified semantic inventory. PropBank framesets provide the canonical predicate definitions, ensuring that surface-level syntactic differences do not fragment the underlying meaning representation.

Edges in an AMR graph are labeled with a fixed inventory of approximately 100 semantic relations, including core roles like :ARG0 (prototypical agent) and :ARG1 (prototypical patient), as well as non-core roles such as :location, :time, and :manner. This directed structure explicitly encodes predicate-argument dependencies without relying on syntactic parse trees, making the representation robust across paraphrases and language-specific word orders.

A defining feature of AMR is reentrancy, where a single concept node participates in multiple relations. This mechanism unifies coreference resolution directly into the graph structure. For example, in 'The soldier who was wounded cried,' the soldier node is both the :ARG1 of 'wound-01' and the :ARG0 of 'cry-01,' eliminating the need for separate co-reference chains and enabling compact semantic integration.

Unlike first-order logic representations, AMR does not use quantifier variables or explicit scope operators. Instead, it relies on graph topology and a set of focus relations (e.g., :polarity for negation, :mode for interrogatives) to encode logical structure. This design choice prioritizes broad-coverage semantic parsing over formal theorem proving, making AMR suitable for tasks like summarization and machine translation where complete logical rigor is not required.

AMR parsing involves solving a graph-to-string alignment problem with no explicit mapping between graph nodes and text spans. The parser must simultaneously identify concepts, infer relations, and handle structural inversions where syntactic subjects map to semantic patients (e.g., passive voice). State-of-the-art systems use transition-based parsers or seq2seq models with pointer-generator networks to construct graphs incrementally while resolving these non-local dependencies.

Because AMR abstracts away from syntax and morphology, it functions as a semantic interlingua for cross-lingual applications. Sentences with identical meaning in different languages should produce the same or highly similar AMR graphs. This property enables zero-shot cross-lingual transfer, where a parser trained on English AMR annotations can be adapted to parse other languages by aligning their semantic structures to the same concept inventory.

The task of identifying predicate-argument structures in text—determining 'who did what to whom, when, where, and how.' While SRL produces flat, sentence-level role assignments, AMR extends this into a graph-based representation that abstracts away from syntax entirely. SRL labels like Agent and Patient map conceptually to AMR's :ARG0 and :ARG1 relations, making SRL a foundational precursor to full AMR parsing.

The broader task of converting natural language into formal, machine-readable meaning representations. AMR is one target formalism within this field, alongside others such as:

• Logical forms (lambda calculus, first-order logic)
• SQL queries for text-to-database tasks
• Executable code in domain-specific languages AMR distinguishes itself by prioritizing semantic relations over syntactic fidelity, making it ideal for cross-lingual and abstractive applications.

A unified parsing framework that produces a directed graph of semantic relations between words, integrating predicate-argument structures with additional relations like negation, modality, and quantification. Unlike AMR, which abstracts words into concepts, semantic dependency parsing retains lexical nodes and builds edges directly on tokens. The two formalisms share significant overlap in their treatment of core semantic roles.

The task of identifying all expressions in a text that refer to the same real-world entity. In AMR, coreference is handled through variable co-indexing—multiple mentions of the same entity map to a single graph node. Robust coreference resolution is a critical preprocessing step for multi-sentence AMR parsing, ensuring that pronouns and definite descriptions are correctly grounded to their antecedents in the semantic graph.

The process of determining the exact sense of a predicate in context before assigning semantic roles. In AMR, predicates are mapped to PropBank framesets or ontological concepts, and selecting the wrong sense produces an incorrect graph. For example, the verb 'break' must be disambiguated between 'break-01' (shatter) and 'break-02' (violate a law), each carrying distinct argument structures in the resulting AMR.

A sequence labeling encoding where tokens are tagged as Beginning, Inside, or Outside of a semantic unit. While commonly associated with Named Entity Recognition, BIO tagging has been adapted for AMR parsing as an intermediate representation. Neural parsers can treat AMR generation as a token-to-concept tagging problem, predicting BIO-encoded graph fragments that are then assembled into the final rooted, directed graph structure.