Semantic Parsing

The core output of semantic parsing is a logical form—a formal, unambiguous representation of meaning. Common target languages include:

• Lambda Calculus: Encodes compositional meaning using functions and variables
• Prolog/Datalog: Expresses facts and rules for querying knowledge bases
• SQL: Maps natural questions directly to database queries
• SPARQL: Targets RDF knowledge graphs for semantic web applications

For example, 'Which cities have populations over 1 million?' might parse to λx.city(x) ∧ population(x, >1M).

AMR represents sentence meaning as a rooted, directed, acyclic graph where:

• Nodes are concepts (words, entities, or PropBank framesets)
• Edges are semantic relations (e.g., :ARG0 for agent, :ARG1 for patient)
• Abstraction from syntax means active/passive voice variations produce identical graphs

AMR parsing has become a standard benchmark, with state-of-the-art models using sequence-to-graph transformers to predict node alignments and edge relations jointly.

Semantic parsing relies on the principle of compositionality: the meaning of a complex expression is determined by the meanings of its constituent parts and the rules used to combine them. This is formalized through:

• Categorial grammars that assign syntactic categories with corresponding semantic types
• Lambda expressions that handle variable binding and scope
• Type-raising operations that lift arguments to function types

Compositionality ensures that parsers generalize to novel utterances by recombining known fragments rather than requiring memorized templates.

Grounded parsing connects language to executable actions in a specific environment, such as:

• Knowledge base question answering: Mapping questions to SPARQL or SQL queries against a known schema
• Instruction following: Translating navigation commands ('Go to the red chair') into robot action sequences
• API call generation: Converting user requests into structured function calls with correct parameters

Grounding requires the parser to resolve entity linking (mapping 'Tesla' to a specific KB identifier) and schema alignment (mapping 'cheapest' to an ORDER BY clause) simultaneously.

Modern parsers use encoder-decoder transformers (T5, BART) fine-tuned on utterance-to-meaning pairs. Key architectural patterns include:

• Grammar-constrained decoding: Restricting output tokens to valid logical form syntax at each step
• Copy mechanisms: Allowing the model to copy entity names directly from the input to the output
• Intermediate representations: Parsing to a simplified 'sketch' first, then filling in details
• Reranking: Generating multiple candidate parses and scoring them with a discriminative model

These approaches achieve over 90% accuracy on benchmarks like Spider and GeoQuery.

Beyond single sentences, contextual semantic parsing handles multi-turn interactions where meaning depends on dialogue history:

• Anaphora resolution: Resolving 'it', 'that one', or 'the second option' to prior entities
• Ellipsis recovery: Reconstructing omitted arguments ('Show me flights. [Show me] hotels too.')
• Context carryover: Maintaining active predicates and constraints across turns

This is critical for conversational AI systems where users refine queries incrementally rather than stating complete logical forms each time.