PDDL-style Representations

• PDDL-style representations are a formal, declarative language that encodes symbolic planning domains and instances via distinct domain and problem files.
• They enable modularity and scalability in planning by separating invariant action schemas from instance-specific configurations, supporting benchmark and automated translation workflows.
• Recent advances integrate LLM-driven synthesis and environment feedback to improve semantic fidelity and enable hybrid symbolic–neural planning.

A PDDL-style representation is a formal, declarative encoding of a symbolic planning domain and its instances using the Planning Domain Definition Language (PDDL). This family of representations originated as the language for the International Planning Competition, unifying pre-existing ad hoc syntaxes for STRIPS-style, ADL, and temporal/resource planning tasks. Modern PDDL-style specifications are notable for their bifurcation into a domain file—enumerating type hierarchies, predicates, (optionally) functions, and parameterized action schemas—and a problem file—specifying typed objects, initial and goal state formulas, and, in more recent versions, planning metrics. Over the past two decades, PDDL and its descendants have become the de facto interchange standard for symbolic planners as well as the backbone for a wide range of benchmarking, automated translation, and hybrid neurosymbolic planning workflows.

1. Formal Structure and Syntax

The canonical PDDL representation employs two files:

• Domain file: Declares types, predicates, (numeric) functions, and parameterized action schemas. All action dynamics are specified here.
• Problem file: Introduces the concrete (typed) objects, initial state, and goal formula for a planning instance.

A representative BNF for the STRIPS-level fragment is:

DomainFile ::= “(define” DomainDecl RequirementsDecl? TypesDecl? ConstantsDecl? PredicatesDecl? FunctionDecl? ActionDecl* “)” DomainDecl ::= “(domain” Identifier “)” RequirementsDecl ::= “(:requirements” RequirementSymbol+ “)” TypesDecl ::= “(:types” TypeSymbol+ (“–” TypeSymbol)? “)” PredicatesDecl::= “(:predicates” PredicateSchema+ “)” FunctionDecl ::= “(:functions” FunctionSchema+ “)” ActionDecl ::= “(:action” Identifier “:parameters” “(” TypedVarList “)” “:precondition” BoolFormula “:effect” EffectFormula “)” ... ProblemFile ::= “(define” ProblemDecl DomainRef ObjectsDecl? InitDecl GoalDecl “)”

Action schemas are defined as tuples:

$$a = \bigl(\mathrm{name}(a),\ \mathrm{pars}(a),\ \mathrm{pre}(a),\ \mathrm{eff}(a)\bigr)$$

where $\mathrm{pars}(a)$ is a typed variable list, and $\mathrm{pre}(a),\ \mathrm{eff}(a)$ are (possibly conjunctive) sets of literals over these variables.

These representations are strictly syntactic, with explicit typing and arity, enabling both decidable parsing and clear language-level verification of planning concepts (Zhang et al., 2024, Vyas et al., 27 Feb 2025).

2. Extensions and Language Evolution

PDDL has undergone major extensions to address resource, temporal, non-deterministic, and hybrid domains:

• PDDL 2.1 introduced durative actions (explicit “start”, “over all”, “end” qualifiers in conditions/effects), numeric fluents, continuous change (ODE-style assignment), and arbitrary plan metrics (Bacchus, 2011, Geffner, 2011, Boddy, 2011).
• PDDL+ enabled explicit modeling of autonomous processes and events, mapping the language onto the formalism of Hybrid Automata for discrete-continuous domains (Fox et al., 2011).
• Advanced constructs (quantification, conditional effects, trajectory constraints, derived predicates) enable a substantial subspace of first-order logic, subject to computationally driven pragmatic restrictions in planner implementations (Haslum et al., 2024, Elahi et al., 2022).

A key property is that standard PDDL models are “lifted” (schema-based) and fully typed, while problem files remain strictly grounded and instance-specific. This schema/instance split is exploited for domain generalization as well as tractable knowledge engineering (Haslum et al., 2024, Méhus et al., 2012).

3. Model Engineering, Benchmarks, and Automation

PDDL-style representations support modular development, extensibility, and automated benchmarking:

• Domain modularity: Explicit separation between invariant domain models and instance-specific problem files supports reuse and composability; any change in the domain description (such as a new action schema) propagates automatically to all instances (Méhus et al., 2012, Nabizada et al., 7 Jun 2025).
• Benchmarks & competitions: The International Planning Competition (IPC) ecosystem is built on PDDL, facilitating reproducible and comparative evaluation across symbolic planners (Bacchus, 2011, Boddy, 2011).
• Automated translation: Workflows have emerged that automatically generate PDDL files from higher-level system models (e.g., via SysML profiles, BPMN business process diagrams), enabling comprehensive toolchains from system requirements to symbolic plans (Nie et al., 22 Nov 2025, Nabizada et al., 7 Jun 2025).
• Expressivity/tractability tradeoffs: Despite support for quantifiers, conditional effects, and numeric fluents, standard PDDL is restricted (e.g., finite ground action set) to ensure computational feasibility (Geffner, 2011, Elahi et al., 2022).

Automated PDDL extraction pipelines incorporate static consistency checks (OCL invariants, name-uniqueness, type consistency), enabling early detection of modeling errors and seamless scaling across system evolutions (Nabizada et al., 7 Jun 2025).

4. Application: Hybrid Symbolic–Neural Planning and LLMs

The rise of LLMs capable of structured text generation has catalyzed research on both the parsing and synthesis of PDDL (Mahdavi et al., 2024, Vyas et al., 27 Feb 2025, Zhang et al., 2024):

• LLM-driven PDDL generation: Off-the-shelf LLMs, in zero-shot or few-shot settings, can parse natural language task/goal specifications and output well-formed PDDL domain and problem files. However, models reliably generate only syntactically correct PDDL—a significant gap remains in aligning generated actions/problems with domain semantics, especially for complex or nuanced tasks. Top models (e.g., GPT-4o) achieve up to 99% parsability but only ~51% action/schema equivalence with gold standards (Vyas et al., 27 Feb 2025).
• Iterative refinement using environment feedback: Enhanced workflows incorporate interaction with a planning environment (executability feedback, random walk metrics) to iteratively correct and improve LLM-generated PDDL toward more semantically faithful models (Mahdavi et al., 2024).
• Partially observable and open-domain settings: LLMs, when coupled with classical planners, enable iterative exploration, correction, and “growing” of domain/problem files under partial information, supporting symbolic reasoning in text-rich or partially specified environments (Gong et al., 19 May 2025, Zhang et al., 2024).
• Prompt engineering and translation back to NL: Automating prompt generation for LLM action selection from PDDL models (via parameterized natural language templates) increases domain independence and facilitates scalable evaluation of LLM-based planning agents (Stein et al., 2023).

Despite these advances, symbolic planners using hand-engineered PDDL continue to outperform LLM end-to-end planners in both coverage and plan quality, highlighting the modeling rigor PDDL enforces (Stein et al., 2023).

5. Modeling, Limitations, and Critiques

Correct PDDL modeling is a distinct challenge, often requiring subtle domain knowledge.

• Modeling idioms: Temporal constraints, resource locking, and concurrency are best handled using localized progressive predicates and axioms (STRIPS/ADL-style) instead of constructs such as “over all,” “at end,” or flexible durations, which can lead to non-Markovian or non-modular models (Bacchus, 2011).
• Complex data types: PDDL proper does not support first-class sets, arrays, or records; complex types must be simulated by flattening into Boolean parameters, resulting in potential combinatorial blowup during grounding. Recent work addresses this via precompiler reductions and auxiliary actions, but tradeoffs in planner performance remain (Elahi et al., 2022).
• Expressivity limits: Exogenous events, true process modeling, and dynamic object creation (as in real-world logistics, software reconfiguration, or dynamic business processes) are not naturally supported in standard PDDL. PDDL+ and trajectory constraints partially address this, but at the cost of increased complexity and undecidability in general (Fox et al., 2011, Méhus et al., 2012, Nie et al., 22 Nov 2025).
• Universal domain construction: Recent theoretical results show that a “universal” PDDL domain can encode arbitrary propositional planning instances, but this universality comes at the price of schematic bloat and complexity, limiting the gains from domain specialization (Haslum et al., 2024).

Critical commentaries emphasize the need for alternative or extended modeling frameworks that better reflect the natural structure of complex planning tasks, balancing language expressiveness with algorithmic tractability (Bacchus, 2011, Boddy, 2011).

6. Integration with Engineering and System Modeling

PDDL-style representations are now routinely produced and consumed by engineering toolchains:

• System modeling integration: Engineering models created in SysML, ACME/Plastik, or BPMN are automatically enriched with PDDL semantics via dedicated profiles and stereotypes. This embedding enables full round-trip engineering, from high-level requirements through code generation to executable planning specifications (Nabizada et al., 7 Jun 2025, Nie et al., 22 Nov 2025, Méhus et al., 2012).
• Formal verification: The static nature and strict typing of PDDL support ahead-of-time verification of domain and problem consistency, early detection of schema violations, and propagation of design changes into valid planning instances.
• Domain reuse and maintainability: Profile-based approaches ensure that domain-independent PDDL templates, once integrated into a system model, can be reused across domains (e.g., manufacturing, logistics, software reconfiguration), reducing manual effort and increasing maintainability (Nabizada et al., 7 Jun 2025, Méhus et al., 2012).

7. Conclusion and Prospects

PDDL-style representations remain the most widely adopted formalism for symbolic planning, enabling rigorous benchmark design, scalable tool integration, and systematic empirical evaluation of planners and neurosymbolic systems alike. Their strict syntactic and semantic structure is essential for automated reasoning, at the cost of modeling complexity and some rigidity. Progress in automated PDDL synthesis, environment-driven correction, and semantic guidance (e.g., via environment feedback or intermediate formalizations) is steadily closing the gap between human-authored and machine-generated planning models (Mahdavi et al., 2024, Vyas et al., 27 Feb 2025, Gong et al., 19 May 2025, Zhang et al., 2024). Further advances will require hybrid frameworks blending LLM-based translation and explanation with symbolic plan verification and validation, as well as deeper integration with domain-specific modeling tools and richer type systems (Elahi et al., 2022, Nabizada et al., 7 Jun 2025).

References:

(Vyas et al., 27 Feb 2025, Nabizada et al., 7 Jun 2025, Mahdavi et al., 2024, Gong et al., 19 May 2025, Stein et al., 2023, Bacchus, 2011, Geffner, 2011, Zhang et al., 2024, Haslum et al., 2024, Muppasani et al., 2023, Espasa et al., 2023, Nie et al., 22 Nov 2025, Elahi et al., 2022, Fox et al., 2011, Méhus et al., 2012)