Translating Natural Language to Formal Planning Specifications

49 concepts48 papers1 proposal

When asked to write a recipe, plan a trip, or guide a robot through a household chore, modern Large Language Models (LLMs) generate text that looks remarkably coherent. However, beneath this surface fluency lies a profound limitation: LLMs struggle with true logical reasoning and long-horizon planning. If an environment's constraints are tight or its semantic cues are removed, pure neural planning quickly breaks down.

To solve this, a powerful hybrid paradigm has emerged. Instead of forcing neural networks to perform combinatorial search or execute multi-step logic directly, researchers use them as semantic translators. By converting unstructured natural language or visual inputs into rigorous, formal planning languages—such as the Planning Domain Definition Language (PDDL) or Linear Temporal Logic (LTL)—this approach decouples semantic understanding from logical execution. The result is a neuro-symbolic architecture that combines the linguistic flexibility of deep learning with the mathematical guarantees of classical symbolic solvers.

The Planning Paradox of Neural Networks

To understand why translation is necessary, we must look at where end-to-end neural models fail. Planning requires tracking state transitions over time and ensuring that every action satisfies strict preconditions. In a benchmark study, Valmeekam et al. (Large Language Models Still Can't Plan (A Benchmark for LLMs on Planning and Reasoning about Change)) demonstrated that LLMs frequently hallucinate impossible states or violate basic physical constraints when tasked with direct planning. Their performance craters entirely when common-sense semantic cues are replaced with abstract symbols.

This failure stems from a fundamental mismatch between statistical pattern matching and logical deduction. As Hazra et al. (Can Large Language Models Reason? A Characterization via 3-SAT) showed by evaluating models on NP-complete 3-SAT problems, LLMs rely on statistical shortcuts rather than true logical engines. When a problem reaches the mathematical "phase transition" where shortcuts no longer work, neural performance collapses.

Conversely, classical symbolic planners (such as SAT solvers or heuristic search algorithms) excel at navigating these complex state spaces. They guarantee that a plan is valid, optimal, and executable. However, they suffer from a different flaw: they are entirely rigid. They require inputs to be written in precise, formal logic syntax, creating a steep usability barrier for humans.

The core insight of the natural-language-to-symbolic translation paradigm is a clean separation of concerns. The system is split into two distinct phases:

  1. Intent Extraction (The Neural Layer): An LLM acts as a compiler. It takes fuzzy, ambiguous human instructions and maps them to structured domain models, initial states, and goal specifications.
  2. Combinatorial Search (The Symbolic Layer): An external, deterministic solver ingests this formal specification and computes the optimal action sequence.
[Human Instruction] ──> ( LLM / Translator ) ──> [Formal PDDL/LTL] ──> ( Symbolic Solver ) ──> [Guaranteed Plan]

As surveyed by Muise et al. (LLMs as Planning Formalizers: A Survey for Leveraging Large Language Models to Construct Automated Planning Models) and Pallagani et al. (On the Prospects of Incorporating Large Language Models (LLMs) in Automated Planning and Scheduling (APS)), this architecture redefines the role of the language model. It shifts from a fallible reasoner to a semantic parser. According to a comprehensive survey by Wei et al. (PlanGenLLMs: A Modern Survey of LLM Planning Capabilities), integrating language models as translators for classical symbolic solvers dramatically improves planning success rates compared to using the models as end-to-end planners.

Mechanics of the Translation Interface

In practice, this translation process maps natural language verbs and nouns directly to symbolic actions, parameters, and predicates.

For tasks involving strict temporal constraints—such as sequencing steps in a specific order—Mavrogiannis et al. (Cook2LTL: Translating Cooking Recipes to LTL Formulae using Large Language Models) demonstrated how unstructured instructions can be compiled into Linear Temporal Logic (LTL). This ensures that rules like "the water must be boiled before adding the ingredients" are mathematically locked into the goal state.

When applied to physical environments, this translation often incorporates multimodal data. Shirai (Vision-Language Interpreter for Robot Task Planning) developed a framework that utilizes vision-language models to translate both visual scenes and textual commands into machine-readable PDDL files. This grounding mechanism, also highlighted in a systematic review by Davis et al. (Augmented Vision-Language Models: A Systematic Review), allows the system to map high-level human intent directly to the physical state of the world.

Once the formal specification is generated, it is fed into a modular framework. For example, the SymbolicAI framework introduced by Dinu et al. (SymbolicAI: A framework for logic-based approaches combining generative models and solvers) treats generative models as semantic parsers embedded within a larger computational graph, delegating complex logical deduction entirely to specialized external solvers.

Grounding and Executability in Robotics

The primary benefit of this translation layer is that it provides a verifiable bridge to physical execution. In long-horizon robotic manipulation, a single ungrounded action can cause catastrophic failure.

To mitigate this, Liu et al. (DELTA: Decomposed Efficient Long-Term Robot Task Planning using Large Language Models) introduced a framework that uses 3D Scene Graphs to represent the environment, allowing an LLM to autoregressively decompose complex goals into PDDL specifications. Because the output is constrained by mathematically valid logic, the resulting plans achieve near-perfect executability rates.

Furthermore, this translation interface can handle dynamic human feedback. Han et al. (InterPreT: Interactive Predicate Learning from Language Feedback for Generalizable Task Planning) developed a system where an LLM translates natural language corrections from non-expert humans into executable Python code and PDDL domains. This allows the robot to learn new symbolic predicates on the fly while maintaining the safety guarantees of classical planners. This work builds upon a long-standing objective in robotics: bridging the gap between low-level sensorimotor skills and high-level symbolic representations, a foundational concept explored by Konidaris et al. (From Skills to Symbols: Learning Symbolic Representations for Abstract High-Level Planning) and surveyed by Cohen et al. (A Survey of Robotic Language Grounding: Tradeoffs between Symbols and Embeddings).

Closing the Loop via Verification

What happens if the LLM makes an error during the translation phase? Because the output is a formal language, the system does not have to trust the translation blindly. The generated PDDL or LTL can be run through a syntax checker or validator before any physical action is taken.

If the symbolic planner finds that the generated domain model is logically inconsistent or un-solvable, it produces an error trace. This formal feedback can be translated back into natural language and fed back into the LLM, creating an automated self-correction loop.

Yu et al. (Generating Symbolic World Models via Test-time Scaling of Large Language Models) leveraged this exact mechanism by scaling test-time compute through an iterative refinement loop, allowing models to correct their own self-generated world models based on solver feedback.

Similarly, Meng et al. (Leveraging Large Language Models to Repair High-level Robot Controllers from Assumption Violations) demonstrated that when a robot encounters an unexpected assumption violation at runtime, the formal controller specifications can be converted into natural language prompts. The LLM can then reason about the environmental context to generate valid repair candidates, completing a bidirectional loop between neural intuition and symbolic verification.

Key Foundational Work

Sequence-to-Sequence Language Grounding of Non-Markovian Task Specifications (2018) — contributed 1 concept elements to this direction.
From Skills to Symbols: Learning Symbolic Representations for Abstract High-Level Planning (2018) — contributed 1 concept elements to this direction.
Towards an Integration of Golog and Planning (2007) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_formal_logic_translation_9afce9af,
  title = {formal logic translation},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/formal-logic-translation/rdr_9afce9afca684e3aaa95051659e0ab40},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-21},
}

This exact version (version 1, frozen text):

@misc{lacuna_formal_logic_translation_9afce9af_v1,
  title = {formal logic translation},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/formal-logic-translation/rdr_9afce9afca684e3aaa95051659e0ab40/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-21},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake