ActionReasoningBench: Reasoning about Actions with and without Ramification Constraints

## Abstract

Abstract Reasoning about Actions and Change (RAC) has historically played a pivotal role in solving foundational AI problems, such as the frame problem. It has driven advancements in AI fields, such as non-monotonic and commonsense reasoning. RAC remains crucial for AI systems that operate in dynamic environments, engage in interactive scenarios, or rely on commonsense reasoning. Despite substantial advances made by Large Language Models (LLMs) in various AI domains, their performance in RAC remains underexplored. To address this gap, we introduce a new diagnostic benchmark, ActionReasoningBench , which encompasses 8 domains and includes questions for up to 19 action sequences. This benchmark rigorously evaluates LLMs across six key RAC dimensions: Fluent Tracking , State Tracking , Action Executability , Effects of Actions , Numerical RAC , and Composite Questions . LLMs demonstrate average accuracy rates of 73.55%, 65.63%, 58.73%, and 62.38% on the former four dimensions, which are frequently discussed in RAC literature. However, the performance on the latter two dimensions, which introduce complex and novel reasoning questions, the average performance of LLMs is lowered to 33.16% and 51.19%, respectively, reflecting a 17.9% performance decline. We also introduce new ramification constraints to capture the indirect effects of actions, providing deeper insights into RAC challenges. Our evaluation of state-of-the-art LLMs, including both open-source and commercial models, reveals challenges across all RAC dimensions, particularly in handling ramifications, with GPT-4o failing to solve any question and o1-preview achieving a score of only 18.4%.

## 1 Introduction

Reasoning about actions and change (RAC) is a fundamental problem in artificial intelligence, with its roots tracing back to early work from the 1960s (McCarthy et al., ). Initially, research focused on developing logical systems capable of effectively modeling and reasoning about actions and their effects in a dynamic environment. One of the significant challenges in this domain has been succinctly expressing how actions influence changeable properties of the world, known as fluents. For example, consider the statement: “Moving an object from location X to location Y results in the object being at location Y.” While it is relatively straightforward to describe the direct effects on the affected fluents, such as the object’s location, it is much more complex to account for the unaffected fluents, a challenge known as the frame problem. This challenge becomes exacerbated when the descriptions involve relationships between fluents in a state, such as “an object can not be at two different places at the same time”. While such constraints simplify action descriptions by decoupling them from fluents, they introduce indirect effects, or ramifications. For example, the statement “A block is said to be clear if there isn’t any block on top of it” describes a ramification fluent, “clear” dependent on another fluent “on top of.”

It took multiple decades of research to create a comprehensive logical formalization that adequately addressed these issues. It involved the laborious creation of numerous handcrafted rules and logic detailing the effects and preconditions of actions (Reiter, ). However, these tools are limited since they rely on manual effort to translate natural language descriptions of actions and their effects into formal logic representations. To address this challenge, recent research in natural language processing (NLP) has begun exploring the capabilities of LLMs in RAC tasks, as demonstrated by works of He et al. (), Spiliopoulou et al. (), and Banerjee et al. (). However, these studies have not systematically decomposed the complex RAC problem into multiple categories and overlook the critical ramifications of actions seen in real-world scenarios. To address this gap, we introduce ActionReasoningBench, a diagnostic RAC benchmark that aims to pinpoint where modern state-of-the-art LLMs struggle.

We decompose the RAC task into six distinct categories—Fluent Tracking, State Tracking, Action Executability, Effects of Actions, Numerical RAC, and Composite Questions. The first four categories focus on assessing fundamental aspects of RAC, while the latter two introduce more complex and novel question types.
The questions in every category span action sequences ranging from 1 to 19 steps, allowing us to test the RAC capabilities at a series of action sequence ranges.
Additionally, we introduce ramification constraints to represent the indirect effect of actions. These constraints simplify action descriptions and align more closely with real-world conditions but introduce additional complexity, as highlighted by McIlraith (). Specifically, we expand the domains by adding ramification fluents with dependencies up to four levels deep, where actions propagate their effects through multiple layers.

Highlights of our benchmark, ActionReasoningBench, along with the comparison to previous benchmarks on RAC, are presented in Table 1. We evaluate four LLMs–two open-source models, Llama-3.1-8B-Instruct and Llama-3.1-70B-Instruct (Dubey et al., ), as well as two leading proprietary models, GPT-4o (Achiam et al., ) and o1-preview (OpenAI, ). These LLMs were tested on ActionReasoningBench across various RAC categories under different prompt settings, including Zero-shot-CoT (Kojima et al., ) and Few-shot-3 (Brown, ), to assess how performance varies based on these configurations.

Table: Table 1: Differences between ActionReasoningBench (Ours) and previous benchmarks on RAC. PlanBench (Valmeekam et al., ) ; TRAC (He et al., )

Our findings indicate that LLMs face substantial challenges, particularly when addressing complex RAC questions. The average performance of all LLMs on the complex categories decreases by 17.88% compared to the first four basic categories. The best performing LLM, GPT-4o, achieves an average accuracy of 59.91% on these categories. Notably, GPT-4o failed to produce any correct answers for questions involving ramifications constraints, while the o1-preview model achieved an accuracy of only 18.42%. Performance was especially poor in categories like Action Executability, Numerical RAC, and Composite Questions, with further declines observed as the length of action sequences increased. Additionally, LLMs struggled with reasoning in scenarios that combined both true and false fluents, experiencing an average performance drop of 12.16% compared to tasks involving exclusively true or false fluents.

## 2 Related Works

#### Benchmarking reasoning capabilities of LLMs

Evaluating the reasoning capabilities of LLMs has become a key focus in NLP, with increasing efforts to create challenging benchmarks. Notable areas of interest include the evaluation of legal reasoning (Fei et al., ) (Guha et al., ), logical reasoning (Luo et al., ) (Han et al., ) (Patel et al., ) (Parmar et al., ) arithmetic reasoning (Cobbe et al., ) (Miao et al., ), temporal reasoning (Uddin et al., ) (Fatemi et al., ), and commonsense reasoning (Onoe et al., ) (Lin et al., ) (Geva et al., ) (Lourie et al., ). Despite this progress, RAC remains significantly under-explored, even though it plays a crucial role in several of these reasoning tasks, such as commonsense and legal reasoning.

#### RAC and Planning

Previous works, such as those by Valmeekam et al. (), Valmeekam et al. (), and Guan et al. (), have curated benchmarks assessing the performance of LLMs on planning, with limited exploration of RAC. Banerjee et al. () examined the RAC capabilities of LLMs across four domains, focusing only on three question types. Similarly, He et al. () tested LLMs on RAC in a modified version of Blocksworld, employing four question categories—two of which centered on RAC, while the other two emphasized planning. In contrast, our work explores 8 distinct domains and includes 6 different question categories. Additionally, we introduce novel ramifications constraints, adding complexity to the RAC task by introducing indirect effects of actions.

## 3 ActionReasoningBench

This section provides a detailed overview of our benchmark, including its categorization, creation methodology, and validation process. A sample instance is presented in Appendix A, where we also describe the objects, actions, and fluents within the domain.

### 3.1 Question Categories

In our benchmark, the questions are organized into six distinct categories, each designed to assess a specific dimension of RAC. Below, we provide a detailed description of each category.

- 1.
Fluent Tracking - Given the initial state and the sequence of actions performed, this category contains questions about the fluents, i.e. properties of the domain, of an object from the changed state. For instance, in the Grippers domain, a fluent-tracking question might be “List all valid properties associated with ball2.”
- 2.
State Tracking - This category builds upon and extends the concept of Fluent Tracking. It involves querying about the complete set of fluents in the final state. For instance, in the Blocksworld domain, a state-tracking question might be “What are all the valid properties in this state?”
- 3.
Action Executability - This category encompasses two types of questions related to determining the executability of actions. The types of questions within this category are as follows:
(a)
Given an initial state, and a sequence of actions, the question focuses on identifying the first action in the sequence that is not executable.
(b)
Given an initial state and a sequence of actions leading to a final state, the task is to identify all actions that can be executed in the final state. For instance, in the Visitall domain, an action-executability question might be “List all executable actions present in the current state.”
- 4.
Effects of Actions - This category contains questions that explore the outcomes of performing a specific action. For instance, in the Mystery domain, an Effects-of-action question can be “From the current state, the vehicle v0 moves from location l1 to l0, and has fuel-level f6 and f5, which properties of the state will be true now?”
- 5.
Numerical RAC - Questions requiring a numerical response fall under this category. These questions may derive from any of the four previously mentioned categories. For example, in the Spanner domain, a Numerical-RAC question can be “What are the number of executable actions in the current state?”
- 6.
Composite Question - This category contains questions that integrate multiple above-mentioned categories, combining up to three distinct categories. These questions require multiple steps of reasoning to arrive at the correct solution. For example, in the Satellite domain, a composite question may combine aspects of Fluent Tracking and Action Executability. An example of such a question could be “List all the properties of the state for satellite0 before the first infeasible action in the sequence?”

### 3.2 Fluent Categories

We further divide the fluents of all 8 domains into three distinct categories, each representing a different aspect of ramifications within RAC.

- 1.
Static Properties - These properties remain unchanged regardless of any action performed. For instance, the property “connected” in the Visitall domain represents whether two locations are connected, a relationship that remains constant irrespective of the robot’s action, which may involve moving, picking up, or placing down objects. In this domain, the connectivity between locations remains unchanged, irrespective of any action.
- 2.
Base Fluents - These fluents can change as a direct result of an action and do not depend on other fluents. For example, in the Grippers domain, the fluent “carry” indicates whether an object is being carried by a robot’s gripper. This fluent can change if the action pick or drop is performed.
- 3.
Ramification Fluents - These fluents are influenced indirectly by other fluents, and action descriptions do not explicitly dictate their changes. Instead, they are determined by the dependencies and relationships within the system. Ramification fluents are further divided into two sub-categories:
(a)
Derived Fluents - These fluents rely on the state of other fluents, reflecting a level of dependency. Changes to them occur as a consequence of changes in the fluents they depend on rather than through direct action. For instance, the fluent “stable” in the Blocksworld domain is considered a derived fluent as its state depends on the fluents “clear” and “on_table”. This relationship can be described as: “Blocks are stable when clear and on the table”. Furthermore, fluent “clear” is itself a derived fluent, dependent on the fluent “on”, which makes “stable” a second-level indirect effect.
(b)
Self-Derived Fluents - These fluents rely on constraints related to themselves rather than other fluents. For example, in the Depot domain, the fluent “at” represents the location of a truck, which can only be at one location at any given time. If the truck is at location l0, it cannot simultaneously be at location l1. Such constraints are explicitly included in the domain description, for example, “A truck can only be in one location at a time”.

Classification of every fluent across all 8 domains can be found in Appendix H. Furthermore, for each fluent type, we generate questions involving negative fluents, which allows us to evaluate LLM’s comprehension of negation within RAC contexts.

### 3.3 Dataset Structure and Variations

#### Selected Domains

The ActionReasoningBench requires domains that facilitate the evaluation of LLMs on both short and long sequences of meaningful actions, where the effects and preconditions of these actions are succinctly described. Additionally, these domains should reflect real-world scenarios. To meet these criteria, we selected 8 domains Blocksworld, Depots, Driverlog, Grippers, Mystery, Satellite, Spanner, and Visitall-sourced from the International Planning Competition (IPC), covering the years 1998 to 2014. These domains are commonly used as benchmarks for evaluating advanced planning systems and provide a robust foundation for research in automated planning. Appendix F provides a detailed description of each domain. Notably, even state-of-the-art LLMs like GPT-4o are not capable of generating diverse domains or action sequences that conform to the precise constraints outlined in these domain descriptions, which justifies the reliance on IPC domains.

#### Domain Descriptions and Ramifications

The domains provided by the IPC are described using the Planning Domain Definition Language (PDDL), a formal language designed to model deterministic actions and state transitions for planning problems. Further information on PDDL can be found in Appendix G.1. In this study, we initially translated the PDDL-based domains into natural language. Subsequently, ramification constraints were introduced into these natural language descriptions. The process underwent validation by two experts in the RAC domain to ensure correctness. Given that the category Action Executability focuses on determining whether the action can be performed rather than analyzing its effect, we concentrated on the categories Fluent Tracking, State Tracking, and Effects of Actions when introducing ramifications.

#### Action-Sequence Lengths

In order to fine-tune LLMs, we generate a comprehensive set of questions that span various action-sequence lengths, specifically 1, 5, 10, 15, and 19. This range is chosen to capture increasing complexities in RAC. We curate a distinct subset of questions with action-sequence lengths of 1, 10, and 19 for evaluation. This subset is selected to assess the model’s performance across the action sequences range.

#### Answer Types

We formulate two distinct types of questions based on the expected answer format. The first type consists of binary questions, where the response is constrained to either “True” or “False”. The second type involves subjective questions, where the answer may encompass a range of multiple objects, actions, or fluents.

### 3.4 Data Creation & Validation

Figure: Figure 1: Overview of the question generation pipeline for ActionReasoningBench. Blue blocks represent “Generated Data”, and green blocks represent “Code used in the pipeline”. Stage 1 involves generating states and plans using Helmert () and validating them with Howey et al. (). In Stage 2, PDDL instances and plans are converted to ASP. Stage 3 computes the action-state space through ASP. Stage 4 generates questions using templates, which are then rephrased to natural language via Llama-3.1-70B-Instruct.
Refer to caption: x1.png

The question generation process follows a four-stage pipeline, as illustrated in Figure 1. The selected domains from the IPC are represented in PDDL (see Appendix F for examples). First, these PDDL representations are used to generate 10 pairs of initial and goal conditions. A PDDL solver (Helmert, ) and validator (Howey et al., ) are then employed to obtain and validate the action sequences necessary to transition from the initial to the goal state. In the second stage, the PDDL domains, instances, and action sequences are converted into Answer Set Programming (ASP) descriptions using Python-based templates.

In the third stage, ASP solvers are used to generate the action-state space and extract fluents for each state, along with identifying all executable and inexecutable actions. Further details on these formal languages are provided in Appendix G. Finally, the fourth stage involves converting the action-state data into questions using a Python template. Up to three natural language variations are created for every object, action, and fluent. These templated sequences are then paraphrased to Llama-3.1-70B-Instruct to ensure they sound natural and avoid repetition in long action sequences. Three independent annotators review both the templated and the paraphrased versions to assess their naturalness, as detailed in Appendix C. Additionally, all eight domain descriptions were manually translated from PDDL to natural language.

### 3.5 Data Splits

Table: Table 2: Overview of the test and train sets of ActionReasoningBench across Question and Fluent Categories. The “Mixed Fluents” category represents questions that involve more than one type of fluent.

The benchmark was divided into two parts: one for training and the other for testing the LLMs, ensuring a balanced representation of question categories across the 8 domains. The Composite Questions category is slightly larger in the test set, as it combines multiple categories, leading to increased questions. Table 2 provides an overview of the distribution of questions and their corresponding categories across both the training and testing sets. The test set contains 3,498 questions, including 2,195 binary and 1,303 free-answer questions. Finally, we designed both zero-shot-CoT and few-shot-3 prompts for all the questions in the test set.

## 4 Experiments and Evaluation

#### Models

To evaluate our benchmark, we tested four different LLMs and employed two prompting techniques. The LLMs include two proprietary state-of-the-art models–GPT-4o (Achiam et al., ) and o1-preview (OpenAI, )–alongside two open-source models, Llama-3.1-8B-Instruct and Llama-3.1-70B-Instruct (Dubey et al., ). Each LLM was evaluated using both few-shot prompting with three examples (few-shot-3) Brown () and zero-shot-CoT Kojima et al. () prompting. While the entire dataset requires reasoning abilities, the ramification subset involves the most complex and challenging reasoning tasks. Given that o1-preview is specifically optimized for reasoning tasks and incurs significantly higher costs compared to GPT-4o(^1^11As of Oct 2024, o1-preview is six times more expensive than GPT-4o [https://openai.com/api/pricing/](https://openai.com/api/pricing/)), we restricted its use to the ramification subset, where its superior reasoning capabilities are expected to provide the greatest benefit. Utilizing o1-preview across the entire dataset would not be cost-effective, as its advantages would be less pronounced for simpler reasoning tasks.

#### Evaluation & Metrics

ActionReasoningBench includes two types of answer formats, as outlined in Section 3.3: binary (true/false) and free-form responses. The evaluation process was performed separately for each answer type. For binary questions, we extracted “true” and “false” keywords from the model’s response and compared them to the ground truth. Since free-form answers can’t be evaluated using exact string matching, we employed human evaluation for the ramification questions. While human evaluation is highly accurate, it is not scalable, so we used Llama-3.1-70B-Instruct to assess all free-form responses. The specific prompt used to evaluate the LLMs and the correlation between Llama-3.1-70B-Instruct and human evaluations are detailed in Appendix E. For all experiments, we report the accuracy along with the standard error of the mean (SEM), calculated as $SEM=\frac{\sigma}{\sqrt{n}}$, where $\sigma$ represents the standard deviation, and $n$ is the sample size.

#### Fine-tuning

We fine-tuned the Llama-3.1-8B model using the training data split outlined in Section 3.5. Due to the limited computing power, we excluded any data samples that exceeded a context length of 4096 tokens. The fine-tuning process was performed separately for free-response and binary questions. Detailed information on the fine-tuning procedure is provided in Appendix D. All experiments were executed using 8×H100 GPUs.

## 5 Results and Discussion

This section presents the results and analysis using ActionReasoningBench as defined in Section 4. The Zero-shot-CoT results for each LLM on both the binary and free-response subsets of the test set are provided in Tables 3 and 4 respectively. Similarly, the Few-shot-3 results for each LLM evaluated on these same subsets are displayed in Tables 6 and 7. The detailed analysis of the effects when ramification constraints are incorporated into the descriptions is discussed in Section 5.1.

Table: Table 3: Performance comparison of GPT-4o, Llama-3.1-8B-Instruct, Llama-3.1-70B-Instruct, and fine-tuned Llama-3.1-8B on the binary subset (True/False) of the benchmark, evaluated without the ramifications constraints using the zero-shot-CoT. The results are categorized up by the action-sequence lengths and question categories.

Table: Table 4: Performance comparison of GPT-4o, Llama-3.1-8B-Instruct, Llama-3.1-70B-Instruct, and fine-tuned Llama-3.1-8B on the free-answer subset of the benchmark, evaluated without the ramifications constraints using the zero-shot-CoT. The results are categorized up by the action-sequence lengths and question categories.

#### Performance across Domains

In our evaluation, GPT-4o demonstrated the highest performance on the Grippers domain and the lowest on the Satellite domain, with a performance gap of 15.53%. For both Llama-3.1-8B-Instruct and Llama-3.1-70B-Instruct, the best performance is also on the Grippers domain, but their worst performance occurs on the Mystery domain, with differences of 19.24% and 24.04%, respectively. Interestingly, the second lowest performing domain for GPT-4o is Mystery, while for the Llama models, it is Satellite. This suggests that despite potential differences in pre-training data, these models exhibit a similar relative understanding of the domains.

#### Decrease in Performance on Complex Questions

The categories of Composite Questions and Numerical RAC build upon the four foundational RAC dimensions. The performance of GPT-4o, Llama-3.1-8B-Instruct, and Llama-3.1-70B-Instruct on free-response complex questions highlights significant challenges, especially in the Numerical RAC category. This category reformulates existing question types into numerical formats, a domain where all tested LLMs exhibit notable difficulty. Specifically, performance on numerical questions related to Action Executability is 8.65% lower than on questions in the Fluent Tracking category. Previous research, such as (Ahn et al., ), indicates that LLMs struggle with arithmetic reasoning, which, when mixed with the RAC questions, likely contributes to the poor performance in the Numerical RAC category.

For Composite Questions, the combination of Fluent Tracking and Action Executability proves easier to answer than the combination of State Tracking and Action Executability, with a 16.32% performance difference. This can be attributed to the fact that the State Tracking category is a superset of the Fluent Tracking category, thereby explaining the observed difference in difficulty.

#### Performance across Fluent Categories

Across all LLMs examined in the study, a consistent trend emerges in which performance on Static Properties decreases as the length of action-sequence increases. While these static properties remain unchanged throughout the actions, they might get overlooked in longer sequences, likely due to their absence in the effect of any action. This phenomenon resembles the “needle in a haystack” challenge in long-context scenarios, where LLMs struggle to recall specific information embedded within a long context (Zhang et al., ). Conversely, Base Fluents maintain stable performance across all action sequences, indicating that the LLMs consistently capture the direct effects of actions. Ramification fluents exhibit a steady decline in performance as the sequence lengthens, particularly affecting the subcategory of Derived Fluents, which suggests that LLMs have more difficulty handling indirect effects. Finally, Mixed Fluents, which involve more than one fluent type, show a consistent decline in performance as the length of action sequences increases.

#### Performance across Action-Sequence Lengths

Figure: Figure 2: Question Categories for both T/F and Free answers as a function of Action-Sequence length for 3 models (zero-shot-CoT). Note: bars represent SEM.
Refer to caption: x2.png

Figure 2 illustrates the performance of the three models–GPT-4o, Llama-3.1-70B-Instruct, and Llama-3.1-8B-Instruct–across varying action sequence lengths in a zero-shot-CoT setting. The results combine both binary and free-response formats, with detailed data available in Tables 3 and 4. Generally, model accuracy declines as the action-sequence length increases, a pattern that holds for most categories. However, GPT-4o deviates from this trend in the State Tracking category, where performance first decreases and then improves. Since this trend is not observed with the other two models, and the results lie within the margin of error, we believe this is an outlier. In contrast, the Effects of Actions category consistently deviates from this trend, likely due to the nature of the task, which focuses on changes resulting from the last action, making it less dependent on the sequence of actions.

#### Model Parameters and Fine-tuning

As demonstrated in Tables 3 and 4, the Llama-3.1-70B-Instruct model consistently outperforms the smaller Llama-3.1-8B-Instruct model, with an average performance improvement of 20.84%. This improvement is likely due to the larger model’s superior reasoning capabilities stemming from its increased number of parameters. A similar trend is observed when comparing GPT-4o to Llama-3.1-70B-Instruct, where GPT-4o exhibits an average performance increase of 8.64%. Although the specific size of GPT-4o remains undisclosed, it is widely speculated to be in the trillions of parameters(^2^22[GPT-4o and Gemini 1.5 Pro: How the New AI Models Compare - CNET](https://www.cnet.com/tech/services-and-software/gpt-4o-and-gemini-1-5-pro-how-the-new-ai-models-compare/)). Notably, fine-tuning the smaller Llama-3.1-8B model on our benchmark’s training set resulted in substantial gains in both binary and free-answer tasks, with an average performance increase of 33.68% across the test set, even outperforming GPT-4o by 4.2%.

#### Impact of Few-Shot Examples on Model Performance

As shown in Tables 3 and 6, the inclusion of few-shot examples for binary answer categories does not significantly enhance model accuracy. This limitation is especially pronounced in models such as GPT-4o and Llama-3.1-70B-Instruct, which exhibit a relative performance decline of approximately 3.5% compared to zero-shot-CoT conditions. We hypothesize that this decrease may be attributed to the few-shot examples inadvertently leading the model toward detecting spurious correlations. In contrast, the model relies more heavily on its internal reasoning capabilities in a zero-shot-CoT setting, potentially mitigating biases introduced by example-driven patterns. However, as seen from Tables 4 and 7, the few-shot approach shows effectiveness in free-answer questions only open-source LLMs.

#### LLMs Struggle with Negative Fluents

Our study reveals a consistent pattern across all the LLMs examined, wherein their performance declines when tasked with questions involving negative fluents compared to those focused on fluents that are true. Specifically, we observed a 12.16% decrease in accuracy on these negative fluent tasks. Furthermore, when questions required reasoning about both true and false fluents simultaneously, LLMs exhibited competence in identifying the true fluents but demonstrated difficulty in correctly recalling the false ones.

### 5.1 Ramifications Results

Table: Table 5: Performance comparison of GPT-4o and o1-preview on the free-answer subset of the benchmark, evaluated with the ramifications constraints using the zero-shot-CoT. The results are categorized up by the action-sequence lengths and question categories.

As discussed in Section 4, the performance on ramification fluents is evaluated for two LLMs: GPT-4o, the highest-performing LLM, and o1-preview, the most recent state-of-the-art LLM. Table 5 presents the performance of both models when ramification constraints are introduced. Further examples of the model responses to ramification-related questions can be found in the Appendix I

#### GPT-4o Performance

GPT-4o did not answer any ramification-related questions correctly, as depicted in Table 5. Upon manual inspection of its outputs, it became evident that GPT-4o frequently failed to mention ramification fluents, even when these were explicitly detailed in the domain description. In instances where it did address ramification fluents, the responses were incorrect or incomplete, with some fluents being omitted. We hypothesize that GPT-4o may have encountered the domain data during pre-training and relied on memorized effects of actions, as the experimental domains were derived from publicly available IPC datasets. Since the ramification fluents were manually created and integrated for this study, this evaluation assesses the model’s reasoning abilities without leveraging pre-existing knowledge. This likely explains why GPT-4o failed to generate ramification fluents, as its pre-training included only the original fluents from the domains.

#### o1-preview Performance

o1-preview, a recently developed LLM optimized for reasoning tasks and incorporating a novel run-time inference mechanism OpenAI (), demonstrated significantly better performance on ramification-related questions compared to GPT-4o, as presented in Table 5. A detailed review of its outputs showed that o1-preview can correctly identify most ramification fluents. However, the model struggles with fluents involving negation, which consistently poses a challenge. It often omitted certain fluents in its final answers and, in some cases, incorrectly evaluated the ramification fluents.

## 6 Conclusion

In this work, we introduced a new diagnostic benchmark, ActionReasoningBench, designed to comprehensively evaluate the performance of large language models (LLMs) on reasoning about actions and change (RAC). By assessing various LLMs across eight domains and six key dimensions of RAC, our findings indicate that while LLMs demonstrate moderate proficiency on traditional RAC tasks, such as Fluent Tracking, State Tracking, Action Executability, and Effects of Actions, they exhibit significant challenges when addressing more complex and novel questions, particularly in areas like Numerical RAC and Composite Questions, with an average performance drop of 17.9%. This highlights a substantial gap in the current ability of LLMs to handle complex reasoning tasks.

Additionally, we explored the indirect effects of actions, known as ramifications, where even state-of-the-art models show considerable limitations. For example, GPT-4o could not solve any questions involving ramifications, and the o1-preview model achieved a low score of 18.4%. These results underscore the pressing need for further research and advancements in RAC reasoning, especially in addressing indirect effects and more advanced reasoning tasks. Improving LLMs’ capabilities in these areas is crucial for enhancing their performance in dynamic and interactive environments. Our findings reinforce the challenges LLMs face in RAC tasks, which, despite their polynomial complexity in cases without ramifications, serve as prerequisites for more advanced planning problems that are often NP-complete or beyond. Improving LLM performance in RAC is a pivotal step toward overcoming broader planning challenges.

## 7 Limitations & Future Work

While ActionReasoningBench provides a diagnostic assessment of LLMs on RAC, it represents an early step in this area and has several limitations, including but not limited to the following:

- 1.
Although RAC is not inherently dependent on the English language, the current version of ActionReasoningBench is limited to questions formulated in English.
- 2.
Although there are more complex types of RAC, exploring those remains beyond the scope of this work and is left as a direction for future research.
- 3.
While the IPC domains in our work cover many scenarios, they may introduce a bias towards planning-specific domains. Expanding the dataset to include more domains could help mitigate this bias.
- 4.
Despite our efforts to evaluate a variety of LLMs, including open and proprietary LLMs, our assessment did not cover models with different architectures or training approaches due to resource limitations.
- 5.
Recent studies by Long et al. () and Tam et al. () indicate that LLM performance can fluctuate depending on the prompt format. This variation may lead to a marginal improvement in the performance of LLMs on ActionReasoningBench.
- 6.
Our free-answer evaluation, which relies on prompting Llama-3.1-70B-Instruct, isn’t perfect and reflects an ongoing challenge of evaluating the free-answers within the NLP community.

## Appendix A Describing an Instance from ActionReasoningBench

In the domain description, actions and their corresponding effects on the state are outlined, including the necessary conditions for performing these actions. The initial conditions describe the starting configuration of objects within the domain. A typical scenario involves executing a sequence of actions that alter the configuration of the state, followed by a query. In the example provided, the question falls under the category of fluent tracking, which asks about a specific set of properties associated with the object ”block b7” after one action has been performed.

The objects involved in this example are as follows:

- •
block b1
- •
block b2
- •
block b3
- •
block b4
- •
block b5
- •
block b6
- •
block b7
- •
hand

The properties of the “block” object include:

- •
Block X on top of block Y
- •
Block X is on the table
- •
Block X is clear
- •
Block X is stable
- •
Block X can be painted
- •
Block X can be displayed
- •
Block X is held

The properties of the “hand” object are:

- •
The hand is empty
- •
The hand is holding block x

Several ramification constraints (i.e., properties that depend on other properties) are present in “Blocksworld”:

- •
Clear: depends on the properties ”on top of” and ”held”
- •
Stable: depends on the properties ”clear” and ”on the table”
- •
Paint: depends on the properties ”stable” and ”hand is empty”
- •
Display: depends on the properties ”painted” and ”on top”
- •
On top of: depends on itself, since a block can’t be at two locations at the same time
- •
Hand is holding a block: depends on itself, since the hand cannot hold two blocks at the same time

The valid actions that can be performed within this domain include:

- •
Picking up a block
- •
Putting down a block
- •
Stacking a block on top of another block
- •
Unstacking a block from top of another block

## Appendix B Few Shot 3 Results

Table 6 and 7 presents the results using the Few-shot-3 setting. These tables support the results showed in Section 5.

Table: Table 6: Performance comparison of GPT-4o, Llama-3.1-8B-Instruct, and Llama-3.1-70B-Instruct, on the binary subset (True/False) of the benchmark, evaluated without the ramifications constraints using the Few-shot-3 setting. The results are categorized up by the action-sequence lengths and question categories.

Table: Table 7: Performance comparison of GPT-4o, Llama-3.1-8B-Instruct, and Llama-3.1-70B-Instruct, on the free answer subset of the benchmark, evaluated without the ramifications constraints using the Few-shot-3 setting. The results are categorized up by the action-sequence lengths and question categories.

## Appendix C Data Verification

To ensure the soundness of our benchmark, we employed three independent annotators who had no prior involvement with the project. Their task was to evaluate the naturalness of the sentences by assigning a score from 1 to 5, where 1 indicates the least natural and 5 most natural. To make sure that rephrasing the templated questions using Llama-3.1-70B-Instruct helps, we sample from each domain in the dataset was represented by 5 randomly sampled instances, resulting in a total of 65 samples across all domains for both templated questions and rephrased questions, resulting in a total of 130 samples. The annotators were provided with both the sampled instances and the following instructions:

Table 8 summarizes the naturalness scores assigned by annotators across all domains in ActionReasoningBench. The templated dataset received an average naturalness score of 4.2 out of 5, while the paraphrased version scored 4.5, indicating the high effectiveness of Llama-3.1-70B-Instruct in enhancing the fluency of the data. We would like to point out that the annotators participated on a voluntary basis and were informed beforehand that no financial compensation would be provided for their contribution.

**Table 8: Naturalness scores assigned by three annotators on a scale of 1 to 5, where 1 indicates completely incoherent text and 5 indicates natural-sounding questions. The table presents scores for both the templated questions and paraphrased questions.**
| Domain | Annotator 1 | Annotator 2 | Annotator 3 | Average |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
|  | Templated | Rephrased | Templated | Rephrased | Templated | Rephrased | Templated | Rephrased |
| Blocksworld | 3.8 | 4.8 | 5.0 | 4.6 | 3.8 | 4.2 | 4.2 | 4.5 |
| Depots | 4.6 | 4.8 | 3.6 | 4.8 | 4.0 | 4.0 | 4.1 | 4.5 |
| Driverlog | 4.8 | 4.8 | 3.6 | 4.2 | 4.4 | 4.6 | 4.3 | 4.5 |
| Grippers | 4.6 | 5.0 | 4.0 | 4.8 | 4.6 | 4.8 | 4.4 | 4.9 |
| Mystery | 4.0 | 4.8 | 4.0 | 4.4 | 3.6 | 4.0 | 3.9 | 4.4 |
| Satellite | 4.4 | 4.8 | 4.6 | 4.4 | 4.4 | 4.2 | 4.5 | 4.5 |
| Spanner | 5.0 | 5.0 | 5.0 | 4.6 | 3.8 | 3.8 | 4.6 | 4.5 |
| Visitall | 3.6 | 4.2 | 3.8 | 4.6 | 4.0 | 4.2 | 3.8 | 4.3 |
| Average | 4.3 | 4.8 | 4.2 | 4.6 | 4.1 | 4.2 | 4.2 | 4.5 |

## Appendix D Fine-tuning Details

In this section, we describe the fine-tuning performed on the training split of ActionReasoningBench described in section 3.5. We fine-tuned Llama-3.1-8B separately for binary (true/false) and free answer questions, using 6 epochs for the former and 18 epochs for the latter. The AdamW optimizer was used, with a batch size of 4 and gradient accumulation steps set to 8 for both of the training setups. Due to the available compute resources, we were limited to a maximum context length of 4096 tokens. This leaves us roughly with 27k samples for binary answers and 14.4k samples for free answer. Tables 9, 10 and 11 show the statistics of the training set that we used to train the models.

**Table 9: Data distribution used for fine-tuning, categorized by response type. The binary question responses are split into “True” and “False”. “Free-Response” indicates the count of open-ended questions in the training set.**
| Answer category | No of Samples |
| --- | --- |
| False | 13,793 |
| True | 13,319 |
| Free-Response | 14,476 |
| Total | 41,588 |

**Table 10: Data distribution used for fine-tuning, categorized by Question Categories.**
| Question category | No of Samples (Binary) | No of Samples(Free-Response) |
| --- | --- | --- |
| Fluent Tracking | 11,674 | 4,946 |
| State Tracking | 2,264 | 1,133 |
| Action Executability | 1,534 | 1,094 |
| Effects of Actions | 1,196 | 1,040 |
| Numerical RAC | 5,757 | 3,293 |
| Composite Questions | 4,687 | 2,970 |
| Total | 27,112 | 14,476 |

**Table 11: Data distribution used for fine-tuning, categorized by Domains.**
| Domain | No of Samples (Binary) | No of Samples (Free-Response) |
| --- | --- | --- |
| Blocksworld | 3,540 | 1,978 |
| Depots | 2,799 | 1,394 |
| Driverlog | 3,404 | 1,785 |
| Grippers | 3,494 | 1,910 |
| Mystery | 2,825 | 1,636 |
| Satellite | 4,037 | 2,073 |
| Spanner | 3,866 | 1,992 |
| Visitall | 3,147 | 1,708 |
| Total | 27,112 | 14,476 |

## Appendix E Free Answers Evaluation Details

We evaluate the free answers using Llama-3.1-70B-Instruct. The following is the few-shot-7 prompt that we used for evaluating the responses:

## Appendix F Domains in ActionReasoningBench

Table: Table 12: Summarizing key characteristics of various domains in ActionReasoningBench including the number of fluents, actions, and objects defined within each domain. Domains are categorized by year of introduction in the IPC and state space complexity, which reflects the difficulty level for AI planners to solve each domain. A larger state space typically indicates greater complexity and presents more significant challenges for traditional AI planners. “N” represents the number of objects in each instance. For example, in the Spanner domain, N refers to the number of locations, spanners and nuts.

In the following sub-sections, we provide details regarding all the domains used in our study. We first present the PDDL description that is given in the IPC and then present how state-space calculation is performed for that domain. State space represents the possible number of interactions that can be performed at a particular state. A higher state-space represents a more difficult problem for traditional AI solvers.

### F.1 Blocksworld

In this domain, we have a set of blocks that can be manipulated using four basic actions: picking up a block from the table, putting down a block onto the table, stacking one block onto another, and unstacking a block from atop another block. The goal is to move and stack these blocks using a robotic hand, following specific rules and conditions.

This domain is formally represented in the IPC using the PDDL as outlined below:

Predicates define the number of fluents in a state:

- •
on(b1,b2)
- •
ontable(b)
- •
clear(b)
- •
holding(b)
- •
handempty

The complexity of a state is, where $N$ is the number of objects

$$ $O(2^{N^{2}+2N})$ (1) $$

### F.2 Depots

The Depots domain models a logistics environment where crates are transported between different locations using trucks and manipulated using hoists. The goal is to efficiently move crates from one location to another, utilizing the available resources (hoists and trucks) while adhering to the constraints defined by the predicates and actions.

This domain is formally represented in the IPC using the PDDL as outlined below:

Predicates define the number of fluents in a state:

- •
(at ?x - locatable ?y - place)
- •
(on ?x - crate ?y - surface)
- •
(in ?x - crate ?y - truck)
- •
(lifting ?x - hoist ?y - crate)
- •
(available ?x - hoist)
- •
(clear ?x - surface))

$$ $O(2^{4N^{2}+2N})$ (2) $$

### F.3 Driverlog

This domain is modeled to simulate logistics operations where drivers, trucks, and objects must be moved between different locations. The primary focus is on transporting objects via trucks, either driven by drivers or moved manually by walking. The key actions in this domain include loading and unloading trucks, drivers boarding and disembarking trucks, driving trucks between connected locations, and walking when no truck is involved.

This domain is formally represented in the IPC using the PDDL as outlined below:

Predicates define the number of fluents in a state:

- •
(at ?obj - locatable ?loc - location)
- •
(in ?obj1 - obj ?obj - truck)
- •
(driving ?d - driver ?v - truck)
- •
(link ?x ?y - location)
- •
(path ?x ?y - location)
- •
(empty ?v - truck)

$$ $O(2^{5N^{2}-N})$ (3) $$

### F.4 Gripper

This domain represents a transportation domain where a robot with two grippers can move between rooms, pick up objects, and drop them off. The robot can only hold one object in each gripper at a time. This domain could solve tasks where the robot needs to transport multiple objects from one room to another by strategically moving, picking up, and dropping items.

This domain is formally represented in the IPC using the PDDL as outlined below:

Predicates define the number of fluents in a state:

- •
(carry ?r - robot ?o - object ?g - gripper)
- •
(at-robby ?r - robot ?x - room)
- •
(at ?o - object ?x - room)
- •
(free ?r - robot ?g - gripper)

$$ $O(2^{N^{3}+3N^{2}})$ (4) $$

### F.5 Mystery

The Mystery domain represents a transportation system where vehicles move between locations, constrained by fuel levels, and can load or unload cargo, constrained by available space. The key aspects of this domain are managing fuel for vehicle movement and managing space for loading and unloading cargo. Locations are connected, and the system also handles fuel transitions, space transitions, and the movement of objects across a grid of locations.

This domain is formally represented in the IPC using the PDDL as outlined below:

Predicates define the number of fluents in a state:

- •
(at ?v - movable ?l - location)
- •
(has-fuel ?l - location ?f - fuel)
- •
(in ?c - cargo ?v - vehicle)
- •
(has-space ?v - vehicle ?s - space)
- •
(conn ?l1 ?l2 - location)
- •
(fuel-neighbor ?f1 ?f2 - fuel)
- •
(space-neighbor ?s1 ?s2 - space)

$$ $O(2^{7N^{2}-3N})$ (5) $$

### F.6 Satellite

The Satellite domain represents a simplified model for managing and controlling satellites and their onboard instruments. The goal in this domain is to coordinate the behavior of satellites, including turning them toward desired directions, powering instruments on and off, calibrating instruments, and capturing images.

This domain is formally represented in the IPC using the PDDL as outlined below:

Predicates define the number of fluents in a state:

- •
(on-board ?i - instrument ?s - satellite)
- •
(supports ?i - instrument ?m - mode)
- •
(pointing ?s - satellite ?d - direction)
- •
(have-image ?d - direction ?m - mode)
- •
(calibration-target ?i - instrument ?d - direction)
- •
(power-avail ?s - satellite)
- •
(power-on ?i - instrument)
- •
(calibrated ?i - instrument)

$$ $O(2^{5N^{2}+3N})$ (6) $$

### F.7 Spanner

This domain models a simple world where a man moves between locations, picks up spanners, and uses them to tighten loose nuts. The actions available to the man involve walking between locations, picking up the spanner, and tightening nuts using the spanner if all conditions are met.

This domain is formally represented in the IPC using the PDDL as outlined below:

Predicates define the number of fluents in a state:

- •
(at ?m - locatable ?l - location)
- •
(carrying ?m - man ?s - spanner)
- •
(link ?l1 - location ?l2 - location)
- •
(useable ?s - spanner)
- •
(tightened ?n - nut)
- •
(loose ?n - nut))

$$ $O(2^{3N^{2}+2N})$ (7) $$

### F.8 VisitAll

The VisitAll domain is focused on controlling a robot that needs to visit all places on a connected grid. The robot’s movement is governed by the connectivity of places, and each move changes the robot’s location and marks the visited place. The task is essentially to traverse the entire grid, visiting every place, while ensuring the robot follows connectivity constraints.

This domain is formally represented in the IPC using the PDDL as outlined below:

Predicates define the number of fluents in a state:

- •
(connected ?x ?y - place)
- •
(at-robot ?x - place)
- •
(visited ?x - place)

$$ $O(2^{N^{2}+N})$ (8) $$

## Appendix G Planning Description and Tools

Planning, at its core, involves determining a sequence of actions that transforms the world from an initial state to a goal state. A world state specifies which fluents are true or false at any given time. The planning domain, denoted as $D$, specifies the fluents, actions, and their effects within the system. Typically, planning domains are represented using formal languages such as PDDL or ASP. In these languages, a transition function $\Phi_{D}:states\times actions\rightarrow states$ defines how actions transform an initial state into a resulting state.

### G.1 Planning Domain Definition Language (PDDL)

PDDL is a formal language developed for expressing planning problems and domain models. Since its inception, PDDL has been extended to address increasingly complex planning scenarios, particularly those involving deterministic problems (Haslum et al., ). PDDL facilitates the specification of both the planning domains and problem instances, including objects, initial, and goal states. In this study, we employ the “STRIPS” (Stanford Research Institute Problem Solver) subset of PDDL (Fikes & Nilsson, ). Additionally, the domains are “typed”, meaning that objects in the planning problem are assigned specific types and subtypes, ensuring a structured representation of the problem space.

### G.2 Answer Set Programming (ASP)

ASP is a declarative approach to problem-solving based on logic programming and non-monotonic reasoning. Unlike traditional planning languages like PDDL, ASP focuses on defining constraints and rules that describe potential solutions, rather than directly encoding state transitions. In ASP, a problem is encoded as a logic program consisting of rules, facts, and constraints, and the solution is an ”answer set” that satisfies all the constraints of the problem. In this study, we use ASP to generate the complete state-space by applying the sequence of actions starting from the initial state.

## Appendix H Classification of Fluents

The subsequent sections provide a detailed classification of fluents across all 13 domains included in ActionReasoningBench, as described in section 3.2.

### H.1 Blocksworld

In the Blocksworld domain, the fluents are categorized as follows:

- 1.
Static Properties - No static properties are present
- 2.
Base Fleunts - onTable(block)
- 3.
Derived Fluents - clear(block), handEmpty
- 4.
Self-Derived Fluents - holding(block), on(block,block)

### H.2 Depots

In the Depots domain, the fluents are categorized as follows:

- 1.
Static Properties - No static properties are present
- 2.
Base Fleunts - No base fluents are present
- 3.
Derived Fluents - clear(surface), available(hoist)
- 4.
Self-Derived Fluents - at(locatable,place), on(crate,surface), in(crate,truck), lifting(hoist,crate)

### H.3 Driverlog

In the Driverlog domain, the fluents are categorized as follows:

- 1.
Static Properties - link(location,location), path(location,location)
- 2.
Base Fleunts - No base fluents are present
- 3.
Derived Fluents - empty(truck)
- 4.
Self-Derived Fluents - at(locatable,location), in(object,truck), driving(driver,truck)

### H.4 Grippers

In the Grippers domain, the fluents are categorized as follows:

- 1.
Static Properties - No static properties are present
- 2.
Base Fleunts - carry(robot,object,gripper)
- 3.
Derived Fluents - free(robot,gripper)
- 4.
Self-Derived Fluents - at_robby(robot,room), at(object,room)

### H.5 Mystery

In the Mystery domain, the fluents are categorized as follows:

- 1.
Static Properties - space_neighbor(space,space), fuel_neighbor(fuel,fuel), conn(location,location)
- 2.
Base Fleunts - No base fluents are present
- 3.
Derived Fluents - No derived fluents are present
- 4.
Self-Derived Fluents - at(movable,location), in(cargo,vehicle), has_space(vehicle,space), has_fuel(location,fuel)

### H.6 Satellite

In the Satellite domain, the fluents are categorized as follows:

- 1.
Static Properties - on_board(instrument,satellite), supports(instrument,mode), calibration_target(instrument,direction)
- 2.
Base Fleunts - power_on(instrument), calibrated(instrument), have_image(direction,mode)
- 3.
Derived Fluents - power_avail(satellite)
- 4.
Self-Derived Fluents - pointing(satellite,direction)

### H.7 Spanner

In the Spanner domain, the fluents are categorized as follows:

- 1.
Static Properties - link(location,location)
- 2.
Base Fleunts - carrying(man,spanner), tightened(nut)
- 3.
Derived Fluents - loose(nut), useable(spanner)
- 4.
Self-Derived Fluents - at(locatable,location)

### H.8 Visitall

In the Visitall domain, the fluents are categorized as follows:

- 1.
Static Properties - connected(place,place)
- 2.
Base Fleunts - No base fluents are present
- 3.
Derived Fluents - visited(place)
- 4.
Self-Derived Fluents - at_robot(place)

## Appendix I Resposnes on Ramification Dataset

In the following sections, we illustrate some instances and responses that we see from GPT-4o and o1-preview.

### I.1 GPT-4o

From the above response, we can see that block b4 is not stable, but the model says it is stable.

### I.2 o1-preview

From the above response, we can see that block b1 is not clear, but the model says it is clear.

## Peer Reviews

confidence: 4
contribution: 4
initial_rating: 8
presentation: 2
questions: - In Table 3, are only the base fluents inclulded in the "Fluent tracking" category?
- Is my understanding correct that when you refer to "introducing ramification constraints", it indicates introducing the ramification fluents in the benchmark?
soundness: 3
strengths: - The paper studies an important but overlooked problem of evaluating RAC capabilities of LLMs in a systematic way, beyond measuring surface RAC. The paper demonstrates through the difference in performance on basic fluents and the ramification fluents, that this is indeed a weakness of current LLMs.

- The paper's conceptualization and discussion of ramification fluents is useful, and the benchmark has potential to lead to interesting new research such as entirely new models for RAC.
summary: This paper introduces ActionReasoningBench, which evaluates LLMs' ability to reason about actions and change in PDDL-based domains. The benchmark introduces novel ramification fluents which require deeper reasoning to infer correctly, such as fluents which are dependent on combinations of other properties, and other properties like "if object is at location a, it cannot also be at location b". The results show that LLMs predict the standard fluents well, but are almost completely failing at such ramification fluents.
weaknesses: I have two main concerns with the paper in its current form:

- Organization: The organization of the paper could be improved, as the main results of the paper appears to be Table 5 (the ramification results), but these experiments are conducted on a smaller set of models and limited to free-answer. The experiments seem a bit incomplete. Other sections like "Performance across Fluent Categories" (l415) should be shown as table/figure. 
- Human baseline: It's difficult to gauge the human upper bound on the benchmark with ramifications, and I would suggest that a human baseline would offer a better way to contextualize the low numbers shown by LLMs.

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: - Why should an LLM alone be used to solve this and not in combination with other systems ? What aspects of the challenges in these individual domains are LLMs most suitable ? Could you please elaborate a bit on this ? 

- What are the current state-of-art (including non-LLM) methods for this ? How do LLMs perform in comparison to them ? 

- Are there any Insights into why numerical RAC performance doesn't seem to improve even after fine-tuning? I was wondering if it was because “number of possible states” is a well-posed problem ? Love to know the authors’ opinion on this 

- (Line 193) What are negative fluents ?

- What happens if we don’t convert the examples into natural language ?  Does the LLM perform any well at all in this task without the natural language conversion step ?
soundness: 3
strengths: - The paper is a step forward towards producing a more challenging benchmark in the domain of reasoning about actions and changes, compared to the previous PlanBench and TRAC work. 

- It also incorporates additional metrics in state tracking that is not part of previous benchmarks. 

- The latest models are also thoroughly evaluated with a good sense of headroom, and will provide a meaningful resource for making progress in this domain.
summary: This paper proposes a reasoning benchmark for reasoning about actions and changes. The focus of this benchmark is specifically on tasks that require state tracking and commonsense, which often requires a full understanding of the current state. The paper aggregates this benchmark using the IPC advance planning competition challenge, by using a pipeline to convert them to natural language and testing it on the latest LLMs. The benchmark reveals headroom for LLMs in the context of state tracking, specifically when ramification constraints are incorporated in the challenge.
weaknesses: - Related work is poorly written. It doesn’t cover the nature of the dataset in the context of existing benchmarks (I had to read the other papers to get a good context). It was hard to identify why this benchmark was the right direction to continue as a benchmark. I highly recommend the authors to expand the related work section placing the contribution in context (particularly for readers like me, who don’t have the full context). 

- Regarding the benchmark itself, the paper doesn’t give enough details on how challenging the individual domains are. It is hard to judge the contribution of the paper well, without those details. Specifically, how were these tasks solved before LLMs were used for these domains? What progress have they made ? While LLMs can be a general model for these tasks, how would they different from building custom models for these tasks ? 

Note: I still very much like this paper, and happy to increase the score if these points above are addressed well.

---

confidence: 3
contribution: 2
initial_rating: 5
presentation: 2
questions: 1. The use of Llama to generate question translations (into natural language) may affect the reasoning capabilities of LLMs, in particular requiring LLMs to use verbal reasoning skills to comprehend the questions. Are LLMs better at handling questions in natural language compared to templated?
soundness: 3
strengths: A strength of this paper is in its comprehensiveness and quantity of analysis. The benchmark  explores many different aspects and ways of querying for action reasoning capabilities, and discovers many interesting trends. The dataset is very large and is able to identify reasoning capabilities which even the most state-of-the-art LLMs do not possess. The method for creating the dataset seems sound as there is a programmatic solution to these types of questions, and humans are used to validate paraphrases. The paper is overall clearly written.
summary: This paper introduces ActionReasoningBench, a benchmark for measuring LM reasoning on action sequences across multiple categories. The benchmark is created by adapting 8 planning domains from the International Planning Competition, and translating them into natural language using a combination of templates and language models. The natural language descriptions and questions are reviewed by annotators. The authors evaluate 4 models on these datasets: GPT-4o, Llama-8b-instruct, LLama-70B-instruct, and fine-tuned Llama-8b. They find that performance generally decreases as a function of action sequence length, and state-of-the-art LMs cannot solve the benchmark, performing particularly poorly on tasks that require numerical reasoning or a combination of other types of action-sequence reasoning (e.g. fluent tracking and action executability). Even GPT4 o1-preview struggles to perform well on inferring ramifications of actions.
weaknesses: 1. The choices of tasks in the paper could be better motivated -- why are the 8 tasks present a representative survey of the important types of action reasoning? Why do we care about these 8 specifically? What are the consequences of LMs being able (or not able) to perform some of these types of reasoning? Why is numerical reasoning included (which is not fully related to action sequences), but not other types of reasoning (e.g. logical)?
2. Without a larger takeaway, this paper risks reading like simply a collection of empirical facts. This paper presents 7-8 separate takeaways in section 5, without too deeply investigating any single one. For example, what kind of errors do LLMs make on ramification fluents? What kind of intuition can we gain about LLMs and their limitations in reasoning from these errors. Having a more coherent high-level claim about all the takeaways from these results can be enlightening. Also having a table summarizing the limitations of LLMs in these 8 aspects could be useful.

---

confidence: 3
contribution: 3
initial_rating: 8
presentation: 3
questions: Have you considered incorporating a combination of automatic evaluation metrics (e.g., BertScore) alongside the current evaluation?
soundness: 3
strengths: - The paper is well written and easy to follow. 
- It provides a comprehensive evaluation framework for LLMs' RAC capabilities, covering a wide range of tasks and difficulties. This benchmark allows for a thorough assessment of LLM performance and identifies areas for improvement such as new key challenges and LLMs limitations.
summary: This paper introduces a new benchmark, ActionReasoningBench, to evaluate LLMs ability to reason about actions and change. This benchmark covers various RAC dimensions, including fluent tracking, state tracking, action executability, effects of actions, numerical RAC, and composite questions. Additionally, the authors introduce a new ramifications constrains to the reasoning task. The paper presents the evaluation of several sota LLMs across the proposed RAC dimensions proving that there is a significant margin of improvement for advanced LLMs such as GPT-4o and o1-preview.
weaknesses: - I am not sure about the exclusive use of LLM to evaluate the free-form answers. It may introduce inaccuracies due to the limitations of language models. While the correlation between Llama-3.1-70B-Instruct and human evaluations is reported, it would be of interest to report evaluation from automatic metrics based on semantic similarity such as Bertscore (among others).
- The fine-grained methodology for evaluating RAC could be further enriched considering aspects such as causal reasoning (this is partially covered by “effects of actions”) and temporal reasoning (for example reasoning about concurrent actions). 
- A short discussion beyond the examples provided in the appendix on how/why LLMs fail (with error analysis) the task would help better motivate the study beyond the performance in term of accuracy.

Meta-review: The paper presents a new benchmark that challenges LLMs by asking them to reason about environments where there is grounded actions that change the world - especially scenarios involving counting and composing various questions. The benchmark is mostly synthetically labelled via an LLM and while their argument that human evaluation is expensive - a small correlational study between human annotators and LLM outputs would have been useful. Most of the reviewers concerns were addressed during the rebuttal period and I'd encourage the authors to incorporate the changes they mention - especially the motivation stemming from the most closely related work.

Decision: Accept (Poster)