Cplus2ASP: Computing Action Language C+ in Answer Set Programming

Abstract: We present Version 2 of system Cplus2ASP, which implements the definite fragment of action language C+. Its input language is fully compatible with the language of the Causal Calculator Version 2, but the new system is significantly faster thanks to modern answer set solving techniques. The translation implemented in the system is a composition of several recent theoretical results. The system orchestrates a tool chain, consisting of f2lp, clingo, iclingo, and as2transition. Under the incremental execution mode, the system translates a C+ description into the input language of iclingo, exploiting its incremental grounding mechanism. The correctness of this execution is justified by the module theorem extended to programs with nested expressions. In addition, the input language of the system has many useful features, such as external atoms by means of Lua calls and the user interactive mode. The system supports extensible multi-modal translations for other action languages, such as B and BC, as well.

• The paper introduces a compiler that translates high-level C+ action descriptions into efficient ASP with formal incremental translation guarantees.
• It employs modular, multi-valued propositional formulas and a reduction strategy ensuring accurate stable model semantics.
• Empirical evaluations show 3–10× speedups in complex planning domains, enhancing scalability and extensibility for action reasoning.

Cplus2ASP v2: Advancing the Compilation of Action Language C+ to ASP

Overview and Context

The paper presents Version 2 of the system Cplus2ASP, which compiles action language ${\cal C}^+$—a high-level formalism for nonmonotonic causal theories and transition system descriptions—into answer set programs (ASP). Cplus2ASP v2 achieves enhanced efficiency and supports the full definite fragment of ${\cal C}^+$, surpassing previous systems both in performance and in the expressivity of the accepted input language.

This system leverages modern ASP solvers, primarily the clingo/iclingo toolchain, and incorporates modular translations based on several recent theoretical results in logic programming and the stable model semantics. Cplus2ASP v2 further introduces incremental execution, rich input features (including multi-valued and defined fluents, macros, and Lua integration), and extensibility to other action languages such as ${\cal B}$ and ${\cal BC}$.

Figure 1: System architecture of Cplus2ASP v2, orchestrating translation, grounding, solving, and answer set post-processing for high-level causal action descriptions.

Theoretical Advances in Compilation from C+ to ASP

The core of Cplus2ASP v2 is a rigorously justified translation pipeline from high-level ${\cal C}^+$ specifications to efficient answer set programs. This process is underpinned by several key formal developments:

• Multi-valued Propositional Formulas under Stable Model Semantics: The system first reinterprets ${\cal C}^+$ action descriptions as multi-valued propositional theories, enabling a natural expression of multi-valued fluents and advanced causal constraints.
• Reduction to Propositional Stable Models: A principled reduction is employed to map these multi-valued formulas to standard propositional logic under the stable model semantics, ensuring a one-to-one correspondence between original multi-valued models and their propositional counterparts.
• Module Theorem for Incremental Execution: The translation is structured to satisfy the acyclicity properties required by the module theorem for stable models, permitting sound incremental reasoning as implemented in iclingo.

Cplus2ASP v2 supports both static and incremental translation modes, with formal correspondences guaranteeing that the computed answer sets faithfully represent the intended models of the original ${\cal C}^+$ theory. The modular translation architecture not only facilitates extensibility to languages like ${\cal B}$ and ${\cal BC}$, but also allows optimization at various stages of the toolchain, from preprocessing to grounding and solving.

System Architecture and Language Support

Cplus2ASP v2 is engineered to maximize flexibility, extensibility, and performance. Notable improvements relative to previous systems include:

• Full Compatibility with CCalc v2 Input Language: All major syntactic constructs (multi-valued and additive fluents, user-defined macros, implicit sort declarations, external function calls, etc.) are supported.
• Extensible Multi-Modal Execution: The system can be configured for multiple input languages and reasoning modes, facilitating experimentation with language features and semantics.
• Rich Integration of External Knowledge: Embedding of Lua scripts during grounding allows incorporation of exogenous computations and nondeterministic effects at translation time, enhancing the expressive power for modeling complex phenomena.
• Interactive and Command-Line Use: Cplus2ASP v2 can be operated via an interactive shell or batch scripts, supporting advanced options for toolchain control, output management, and solution enumeration.

Empirical Evaluation and Numerical Results

Comprehensive benchmarking against previous systems (CCalc v2, Cplus2ASP v1, and coala) demonstrates that Cplus2ASP v2 achieves an order-of-magnitude speedup in large and complex planning domains. Domains evaluated include Traffic World, Blocks World with costs, Spacecraft Integer, Towers of Hanoi, and Ferryman, with horizon lengths and domain sizes that stress the scalability of action reasoning solvers.

Key empirical findings:

• Incremental Mode Outperforms All Baselines: In nearly all tested domains, Cplus2ASP v2 in incremental mode solves instances 3–10 times faster than the best competing modes, including coala's incremental configuration.
• Efficient Handling of Long-Horizon Planning: For instances with long horizons and large search spaces (e.g., Ferryman 120/4), the incremental mode maintains performant scaling by reusing grounded components and learned solver heuristics, whereas static modes incur heavy recomputation costs at each step.

  Figure 3: Long-horizon analysis of Ferryman 120/4 demonstrating substantial cumulative speedups of Cplus2ASP v2's incremental mode over static alternatives.

The speedup is attributed to both architectural optimizations (e.g., reduced number of grounded atoms and rules) and theoretical innovations (module-based incremental translation and minimal repetition in grounding/solving cycles). It is emphasized that in several cases static configurations reached timeouts or exhibited substantially higher memory and runtime footprints, highlighting the practical importance of incremental reasoning for large domains.

Practical and Theoretical Implications

Cplus2ASP v2 establishes a robust pipeline for translating high-level nonmonotonic causal action theories into executable ASP, substantially broadening the practical applicability of action languages. Theoretical contributions—such as the encoding of multi-valued fluents and the modular, incremental compilation strategy—advance the state-of-the-art in both knowledge representation and logic programming.

Implications for future developments include:

• Wider Applicability of Action Languages: By supporting large, expressive fragments and providing scalable computation, action languages may see broader adoption in commonsense reasoning, robotics, workflow analysis, and automated planning.
• Foundation for Extension and Generalization: The modular translation architecture is well-positioned for extension to new action language features, integration with external reasoning engines, or application in multi-agent and dynamically evolving domains.
• Reinforcement of Incremental Reasoning Paradigms: The empirical success of incremental approaches motivates further research into optimizing modularity and reuse in solver pipelines, especially for applications with sequential or iterative structure.

Conclusion

Cplus2ASP v2 delivers significant theoretical and practical improvements over predecessor systems for compiling and reasoning with ${\cal C}^+$ action descriptions in ASP. The combination of full language support, formal translation guarantees, and incremental computation positions it as a state-of-the-art platform for declarative action reasoning and planning. The demonstrated performance and extensibility suggest a compelling path forward for logic-based action formalisms and their deployment in real-world domains.