Abstract
"Ambiguity Procrastination" proposes a design philosophy for natural language interfaces where the system deliberately delays resolving linguistic ambiguities—such as noun compound structures or prepositional phrase attachments—until it has enough semantic or domain-specific knowledge to make an informed decision. By using non-committal intermediate representations, the system (called Lucy) avoids unnecessary search branching and maintains a "monotonic" processing flow where assertions are added but never retracted.
Problem Statement
Natural language is notoriously ambiguous. A single sentence can yield dozens of valid syntactic parses, words often have multiple meanings (lexical ambiguity), and quantifiers like "every" can have varying scopes. Traditional NLP systems in the 1980s typically managed this through two methods: branching (trying every possible parse tree) or early commitment (making a "best guess" and backtracking if proven wrong). Both methods are computationally expensive and complicate software logic. The authors argue for "procrastination" as a simplification: deferring structural decisions until the backend knowledge base provides the necessary context to make the choice obvious.
The Lucy Architecture
The authors implemented these ideas in Lucy, an English interface for knowledge-based systems. The pipeline consists of three main stages designed to minimize early commitment.
1. The Non-Committal Parser
Lucy uses a Combinatory Categorial Grammar (CCG) and a unification-based formalism. Crucially, the parser is designed to be "weak" or "incomplete." When it encounters a complex noun compound like "mean price data," it does not attempt to decide between (mean price) data or mean (price data). Instead, it produces a recursive structure of "modifiers" and "domains" that represents the entire family of possible bracketings without choosing one.
2. Initial Logical Form (ILF)
This intermediate representation maps surface functional relationships (like subject/object) into a logical format without resolving attachments. It utilizes "vague predicates" and dummy arguments (e.g., ARG1) to hold space for decisions that haven't been made yet.
3. Final Logical Form (FLF)
This is where procrastination ends. Lucy consults a semantic lexicon tied to a backend knowledge base and uses constraint satisfaction to identify interpretations consistent with the domain. For instance, if the knowledge base specifies that a certain operation requires a "computable-object," it can resolve whether "mean" refers to a mathematical average or a different semantic entity.
Key Insights and Principles
- Monotonicity: The primary goal is a system where processing only adds information. By procrastinating, the system avoids making assertions that might need to be retracted, simplifying the interaction between syntax, semantics, and discourse modules.
- Wait-and-See Parsing: The parser acknowledges its lack of non-syntactic knowledge and intentionally defers structural descriptions it cannot guarantee.
- Quantifier Handling: Inspired by Discourse Representation Theory (DRT), Lucy uses a representation that allows for late commitment to existential versus universal quantification, avoiding early scope resolution.
Evaluation and Results
Lucy was evaluated using complex illustrative sentences designed to test specific ambiguities, such as noun compounds ("mean price data"), idiomatic structures ("The system looks up the word for the user"), and quantifier scope ("Every command computes a function").
The architectural demonstration showed that:
- Complex noun compounds can be represented as a "family of parses" to be narrowed down later by semantic constraints.
- Prepositional phrase (PP) attachment can be deferred using an attachment list in the ILF, waiting until the domain model can identify valid relationships.
- The overall search space is significantly reduced by avoiding branching during the early syntactic phase.
Limitations and Future Work
While procrastination reduces early branching, the authors note that branching still occurs during the FLF stage if multiple semantic interpretations remain valid. They suggest that a richer constraint language could further decrease this residual branching. Additionally, maintaining strict monotonicity is challenging when syntax, idioms, and PPs interact, sometimes requiring "strained" syntactic bracketings to keep the grammar unambiguous. Future work involves developing more robust heuristics for best-first search when branching is unavoidable.
Summary updated