Original: Generating Data In Planning: SAS + Planning Tasks of a Given Causal Structure
Revised: Generating Data In Planning: SAS + Planning Tasks of a Given Causal Structure

Original: Abstract
Revised: Abstract

Original: The need for data in planning has long been established, by, e.g., machine learning based approaches.
Revised: The need for data in planning has long been established, by, e.g., machine learning based approaches.

Original: The existing data, however, is quite limited.
Revised: The existing data, however, is quite limited.

Original: There exists only a relatively small amount of hand-crafted planning domains, mostly introduced through International Planning Competitions.
Revised: There exists only a relatively small amount of hand-crafted planning domains, mostly introduced through International Planning Competitions.

Original: Further, this collection of domains is not necessarily diverse: many of these domains are some variants of the transportation prob- lem.
Revised: Further, this collection of domains is not necessarily diverse: many of these domains are some variants of the transportation prob- lem.

Original: In this work, we alleviate the shortage in existing planning tasks by automatically generating tasks of a particular causal structure.
Revised: In this work, we alleviate the shortage in existing planning tasks by automatically generating tasks of a particular causal structure.

Original: Given any graph G , we show how to create a SAS + planning task with the causal graph isomorphic to G .
Revised: Given any graph G , we show how to create a SAS + planning task with the causal graph isomorphic to G .

Original: We create a large collection of planning tasks by randomly gen- erating graphs of various structural restrictions and creating planning tasks for these graphs, but also, more importantly, we provide the community with a tool that allows for ondemand generation of additional, possibly larger tasks.
Revised: We create a large collection of planning tasks by randomly gen- erating graphs of various structural restrictions and creating planning tasks for these graphs, but also, more importantly, we provide the community with a tool that allows for ondemand generation of additional, possibly larger tasks.

Original: Our experimental evaluation ensures that the generated collection is interesting for the current state of affairs in classical cost- optimal planning, showing the performance of state-of-the-art symbolic search and explicit heuristic search based planners.
Revised: Our experimental evaluation ensures that the generated collection is interesting for the current state of affairs in classical cost- optimal planning, showing the performance of state-of-the-art symbolic search and explicit heuristic search based planners.

Original: Introduction
Revised: Introduction

Original: Since the ﬁrst planning tasks encoded in STRIPS language back in 1971 (Fikes and Nilsson 1971), data, a.k.a.
Revised: Since the ﬁrst planning tasks encoded in STRIPS language back in 1971 (Fikes and Nilsson 1971), data, a.k.a.

Original: planning tasks, was the corner stone and one of the main drivers of research in planning.
Revised: planning tasks, was the corner stone and one of the main drivers of research in planning.

Original: With the beginning of International
Revised: With the beginning of International

Original: Planning Competitions (IPC) in 1998 (McDermott 2000) came the increase in the availability of planning tasks, with the current estimate of slightly over 70 domains, including some variants in different formalisms.
Revised: Planning Competitions (IPC) in 1998 (McDermott 2000) came the increase in the availability of planning tasks, with the current estimate of slightly over 70 domains, including some variants in different formalisms.

Original: All these domains are hand-crafted, although some correspond to machine translation from a different problem (Palacios and Geffner 2009;
Revised: All these domains are hand-crafted, although some correspond to machine translation from a different problem (Palacios and Geffner 2009;

Original: Bonet, Palacios, and Geffner 2009; Grastien and Scala 2018;
Revised: Bonet, Palacios and Geffner 2009; Grastien and Scala 2018;

Original: Sohrabi et al. 2018).
Revised: Sohrabi et al. 2018).

Original: Not only that most of these domains are hand-crafted, the collection is not necessarily diverse.
Revised: Not only that most of these domains are hand-crafted, the collection is not necessarily diverse.

Original: Many of these domains are some variants of the transportation problem.
Revised: Many of these domains are some variants of the transportation problem.

Original: A major focus in classical planning was on heuristic search, with heuristics automatically obtained for planning 
Revised: A major focus in classical planning was on heuristic search, with heuristics automatically obtained for planning tasks, exploiting the task structure.

Original: Copyright c (cid:13) 2020, Association for the Advancement of Artiﬁcial

Original: Intelligence (www. tasks, exploiting the task structure.

Original: Few examples that explicitly exploit the causal structure include the causal graph heuristic (Helmert 2004) and the structural pattern heuristics (Katz and Domshlak 2010; Katz and Keyder 2012).
Revised: Few examples that explicitly exploit the causal structure include the causal graph heuristic (Helmert 2004) and the structural pattern heuristics (Katz and Domshlak 2010; Katz and Keyder 2012).

Original: Others, such as pattern databases (PDBs) (Edelkamp 2001) exploit the causal information in e.g., pattern selection (Haslum et al. 2007).
Revised: Others, such as pattern databases (PDBs) (Edelkamp 2001) exploit the causal information in e.g., pattern selection (Haslum et al. 2007).

Original: Merge-and-shrink heuristics (Helmert,
Revised: Merge-and-shrink heuristics (Helmert,

Original: Haslum, and Hoffmann 2007) use the causal graph for guiding the merge process.
Revised: Haslum, and Hoffmann 2007) use the causal graph for guiding the merge process.

Original: Most existing heuristics that work on the multi-valued representation exploit the causal information in one way or another.
Revised: Most existing heuristics that work on the multi-valued representation exploit the causal information in one way or another.

Original: Further, starting with the seminal work of B¨ackstr¨om and Nebel (1995), the research on the complexity of planning tasks had a major focus on the characterization of planning fragments by their causal graph structure (Domshlak and Brafman 2002; Katz and Domshlak 2007; 2008; Gim´enez and Jonsson 2008; 2009; Katz and Keyder 2012), as well as some local structural characteristics, such as k-dependence (Katz and Domshlak 2007;
Revised: Further, starting with the seminal work of B¨ackstr¨om and Nebel (1995), the research on the complexity of planning tasks had a major focus on the characterization of planning fragments by their causal graph structure (Domshlak and Brafman 2002; Katz and Domshlak 2007; 2008; Gim´enez and Jonsson 2008; 2009; Katz and Keyder 2012; B¨ackstr¨om and Jonsson 2013; Aghighi, Jonsson, and St˚ahlberg 2015; B¨ackstr¨om, Jonsson, and Ordyniak 2019), as well as some local structural characteristics, such as k-dependence (Katz and Domshlak 2007;

Original: Gim´enez and Jonsson 2012), showing these fragments to belong to a variety of complexity classes.
Revised: Gim´enez and Jonsson 2012), showing these fragments to belong to a variety of complexity classes.

Original: For these two reasons, various planners performance heavily relies on the various structural characteristics of the input planning task.
Revised: For these two reasons, various planners performance heavily relies on the various structural characteristics of the input planning task.

Original: The aim of this work is to generate planning tasks of a speciﬁc predeﬁned structure.
Revised: The aim of this work is to generate planning tasks of a speciﬁc predeﬁned structure.

Original: Here, we focus on the characterization of planning tasks by the structure of their causal graphs.
Revised: Here, we focus on the characterization of planning tasks by the structure of their causal graphs.

Original: Given a collection of multi-valued variables and a graph representing causal connections between these variables, we propose a way of generating SAS + actions, initial state and a goal, in a way that the causal graph of the resulting task will match the input graph.
Revised: Given a collection of multi-valued variables and a graph representing causal connections between these variables, we propose a way of generating SAS + actions, initial state and a goal, in a way that the causal graph of the resulting task will match the input graph.

Original: Our aim is to be able to automatically generate a diverse collection of planning tasks, as large as needed for various purposes.
Revised: Our aim is to be able to automatically generate a diverse collection of planning tasks, as large as needed for various purposes.

Original: One such example purpose is learning a good planner selection strategy (Sievers et al. 2019;
Revised: One such example purpose is learning a good planner selection strategy (Sievers et al. 2019;

Original: Ma et al. 2020)
Revised: Ma et al. 2020)

Original: Another possible purpose is an additional source of benchmarks for empirical evaluation of new planning algorithms.
Revised: Another possible purpose is an additional source of benchmarks for empirical evaluation of new planning algorithms.

Original: We test the generated collection with two modern cost-optimal planners that represent the two popular state-of-the-art approaches to costoptimal planning.
Revised: We test the generated collection with two modern cost-optimal planners that represent the two popular state-of-the-art approaches to costoptimal planning.

Original: For symbolic search, we chose the planner
Revised: For symbolic search, we chose the planner

Original: S YM BA ∗ (Torralba et al. 2014), winner of the sequential optimal track of International Planning Competition 2014 and one of the planners in the winning portfolio of IPC
Revised: S YM BA ∗ (Torralba et al. 2014), winner of the sequential optimal track of International Planning Competition 2014 and one of the planners in the winning portfolio of IPC

Original: (Katz et al. 2018).
Revised: (Katz et al. 2018).

Original: For heuristic search, we chose A ∗ with
Revised: For heuristic search, we chose A ∗ with

Original: LM-cut heuristic (Helmert and Domshlak 2009), a component of many modern heuristics search based planners.
Revised: LM-cut heuristic (Helmert and Domshlak 2009), a component of many modern heuristics search based planners.

Original: Our experiments conﬁrm that (i) the generated collection is challenging for both heuristic search and symbolic search based planners, and (ii) there is no clear dominance to any of the techniques.
Revised: Our experiments conﬁrm that (i) the generated collection is challenging for both heuristic search and symbolic search based planners, and (ii) there is no clear dominance to any of the techniques.

Original: Therestof the paper is structured as follows.
Revised: The rest of the paper is structured as follows.

Original: We start with introducing the planning formalism and the notation used throughout the paper.
Revised: We start with introducing the planning formalism and the notation used throughout the paper.

Original: We then move to construction, where we ﬁrst describe various causal graph structures and the way these graphs can be constructed, and then describe the construction of planning tasks given a causal graph.
Revised: We then move to construction, where we ﬁrst describe various causal graph structures and the way these graphs can be constructed, and then describe the construction of planning tasks given a causal graph.

Original: Next, we present the experimental evaluation, including describing the way we have created our collection.
Revised: Next, we present the experimental evaluation, including describing the way we have created our collection.

Original: Finally, we discuss the related work, and conclude with the summary of our results and future work.
Revised: Finally, we discuss the related work, and conclude with the summary of our results and future work.

Original: Preliminaries
Revised: Preliminaries

Original: A SAS + planning task (B¨ackstr¨om and Nebel 1995) is given by a tuple (cid:104)V , A, s 0 , s ∗ (cid:105) , where V is a set of state variables , A is a ﬁnite set of actions .
Revised: A SAS + planning task (B ¨ ackstr ¨ om and Nebel 1995) is given by a tuple (cid:104)V , A, s 0 , s ∗ (cid:105) , where V is a set of state variables , A is a ﬁnite set of actions .

Original: Each state variable v ∈ V has a ﬁ- nite domain dom ( v ) .
Revised: Each state variable v ∈ V has a ﬁ- nite domain dom ( v ) .

Original: Each pair (cid:104) v, ϑ (cid:105) of variable v ∈ V and its value ϑ ∈ dom ( v ) is called a fact .
Revised: Each pair (cid:104) v, ϑ (cid:105) of variable v ∈ V and its value ϑ ∈ dom ( v ) is called a fact .

Original: By F v we denote the set {(cid:104) v, ϑ (cid:105)
Revised: By F v we denote the set {(cid:104) v, ϑ (cid:105)

Original: | ϑ ∈ dom ( v ) } of facts for the variable v , and the set of all facts is denoted by F := (cid:83) v ∈V F v .
Revised: | ϑ ∈ dom ( v ) } of facts for the variable v , and the set of all facts is denoted by F := (cid:83) v ∈V F v .

Original: A (partial) assignment to the variables V is called a (partial) state .
Revised: A (partial) assignment to the variables V is called a (partial) state .

Original: Often it is convenient to view partial state p as a set of facts with (cid:104) v, ϑ (cid:105) ∈ p
Revised: Often it is convenient to view partial state p as a set of facts with (cid:104) v, ϑ (cid:105) ∈ p

Original: if and only if p [ v ] = ϑ .
Revised: if and only if p [ v ] = ϑ .

Original: For a partial assignment p ,
Revised: For a partial assignment p ,

Original: V ( p ) ⊆
Revised: V ( p ) ⊆

Original: V denotes the subset of state variables instantiated by p .
Revised: V denotes the subset of state variables instantiated by p .

Original: Partial state p is consistent with state s if p ⊆ s .
Revised: Partial state p is consistent with state s if p ⊆ s .

Original: We denote the set of states of a planning task by S .
Revised: We denote the set of states of a planning task by S .

Original: s 0 is the initial state , and the partial state s ∗ is the goal .
Revised: s 0 is the initial state , and the partial state s ∗ is the goal .

Original: Each action a is a pair (cid:104) pre ( a ) , eﬀ ( a ) (cid:105) of partial states called preconditions and effects .
Revised: Each action a is a pair (cid:104) pre ( a ) , eﬀ ( a ) (cid:105) of partial states called preconditions and effects .

Original: By prv ( a ) we denote the part of the precondition that corresponds to variables that do not participate in action’s effects, prv ( a ) = {(cid:104) v, ϑ (cid:105) ∈
Revised: By prv ( a ) we denote the part of the precondition that corresponds to variables that do not participate in action’s effects, prv ( a ) = {(cid:104) v, ϑ (cid:105) ∈

Original: pre ( a ) | v (cid:54)∈ V ( eﬀ ( a )) }  .
Revised: pre ( a ) | v (cid:54)∈ V ( eﬀ ( a )) } , also called prevail condition .

Original: An action cost is a mapping C :
Revised: An action cost is a mapping C :

Original: A → R 0+ .
Revised: A → R 0+ .

Original: An action a is applicable in a state s ∈ S if and only if pre ( a ) is consistent with s .
Revised: An action a is applicable in a state s ∈ S if and only if pre ( a ) is consistent with s .

Original: Applying a changes the value of v ∈ V ( eﬀ ( a )) to eﬀ ( a )[ v ] .
Revised: Applying a changes the value of v ∈ V ( eﬀ ( a )) to eﬀ ( a )[ v ] .

Original: The resulting state is denoted by s (cid:74) a (cid:75) .
Revised: The resulting state is denoted by s (cid:74) a (cid:75) .

Original: An action sequence π = (cid:104) a 1 , . .
Revised: An action sequence π = (cid:104) a 1 , . .

Original: . , a k (cid:105) is applicable in s if there exist states s 0 , · · · , s k such that (i) s 

Revised: . , a k (cid:105) is applicable in s if there exist states s 0 , · · · , s k such that (i) s

Original: = s , and (ii) for each≤ i ≤ k , a
Revised: = s , and (ii) for each≤ i ≤ k , a

Original: i is applicable in s i − 1 and s i
Revised: i is applicable in s i − 1 and s i

Original: = s i − 1 (cid:74) a i (cid:75) .
Revised: = s i − 1 (cid:74) a i (cid:75) .

Original: We denote the state s k by s (cid:74) π (cid:75) .
Revised: We denote the state s k by s (cid:74) π (cid:75) .

Original: π is a plan iff π is applicable in s 

Revised: π is a plan iff π is applicable in s

Original: and s ∗ is consistent with s(cid:74)
Revised: and s ∗ is consistent with s(cid:74)

Original: π (cid:75) .
Revised: π (cid:75) .

Original: We denote by P (Π) (or just P when the task is clear from the context) the set of all plans of Π .
Revised: We denote by P (Π) (or just P when the task is clear from the context) the set of all plans of Π .

Original: The cost of a plan π , denoted by C ( π ) is the summed cost of the actions in the plan.
Revised: The cost of a plan π , denoted by C ( π ) is the summed cost of the actions in the plan.

Original: A central role in what follows is played by a standard structure in classical planning, called causal graph (Helmert 2004).
Revised: A central role in what follows is played by a standard structure in classical planning, called causal graph (Helmert 2004).

Original: The causal graph CG Π of a task Π is a digraph with vertices V .
Revised: The causal graph CG Π of a task Π is a digraph with vertices V .

Original: An arc ( v, v (cid:48) ) is in CG Π
Revised: An arc ( v, v (cid:48) ) is in CG Π

Original: iff v (cid:54) = v (cid:48) and there exists an action a ∈
Revised: iff v (cid:54) = v (cid:48) and there exists an action a ∈

Original: A such that ( v, v (cid:48) ) ∈
Revised: A such that ( v, v (cid:48) ) ∈

Original: [ V ( eﬀ ( a )) ∪
Revised: [ V ( eﬀ ( a )) ∪

Original: V ( pre ( a ))]
Revised: V ( pre ( a ))]

Original: × V ( eﬀ ( a )) .
Revised: × V ( eﬀ ( a )) .

Original: For an action a , by E a we denote the set of all such arcs, and by E A (cid:48)
Revised: For an action a , by E a we denote the set of all such arcs, and by E A (cid:48)

Original: we denote the union of all sets of arcs E a for a ∈ A (cid:48) .
Revised: we denote the union of all sets of arcs E a for a ∈ A (cid:48) .

Original: Another structure typically used in planning for computing relaxation based heuristics is relaxed planning graph[Figure] (Hoffmann and Nebel 2001), which is a layered graph of facts and actions, describing action application in the planning task, under value accumulating semantic.
Revised: Another structure typically used in planning for computing relaxation based heuristics is relaxed planning graph (Hoffmann and Nebel 2001), which is a layered graph of facts and actions, describing action application in the planning task, under value accumulating semantic.

Original: The layers are added until a ﬁxpoint is reached, that is no new fact can be achieved.
Revised: The layers are added until a ﬁxpoint is reached, that is no new fact can be achieved.

Original: The ﬁrst fact layer F 1 thus corresponds to the facts from the initial state, and the last layer is also a fact layer, and it is equal to the preceding fact layer.
Revised: The ﬁrst fact layer F 1 thus corresponds to the facts from the initial state, and the last layer is also a fact layer, and it is equal to the preceding fact layer.

Original: Each action layer A i consists of all actions from A that are applicable in
Revised: Each action layer A i consists of all actions from A that are applicable in

Original: F i , that is A i
Revised: F i , that is A i

Original: = { a ∈ A | pre ( a ) ⊆
Revised: = { a ∈ A | pre ( a ) ⊆

Original: F i } .
Revised: F i } .

Original: The next fact layer F i +1 is then constructed by adding to F i all facts achieved by the actions in A i , namely F i +

Revised: The next fact layer F i +1 is then constructed by adding to F i all facts achieved by the actions in A i , namely F i +

Original: =
Revised: =

Original: F i ∪ (cid:83) a ∈
Revised: F i ∪ (cid:83) a ∈

Original: A i eﬀ ( a ) .
Revised: A i eﬀ ( a ) .

Original: Finally, SAS + representation is often not provided directly, and is translated from STRIPS representation (Helmert 2006).
Revised: Finally, SAS + representation is often not provided directly, and is translated from STRIPS representation (Helmert 2006).

Original: The multi-valued variables in SAS
Revised: The multi-valued variables in SAS

Original: + then correspond to invariant groups of pairwise mutually exclusive facts (mutexes), where exactly one such fact is true in any state reachable from the initial state.
Revised: + then correspond to invariant groups of pairwise mutually exclusive facts (mutexes), where exactly one such fact is true in any state reachable from the initial state.

Original: Each such invariant group over STRIPS facts corresponds to a set of facts at most one of which can be true in any given state that is reachable from the initial state.
Revised: Each such invariant group over STRIPS facts corresponds to a set of facts at most one of which can be true in any given state that is reachable from the initial state.

Original: If there exist such states where no facts are true, then an additional value is added, representing that none of the facts in the invariant group is true.
Revised: If there exist such states where no facts are true, then an additional value is added, representing that none of the facts in the invariant group is true.

Original: Construction
Revised: Construction

Original: We start our construction by deﬁning a graph to be served as the causal graph of the constructed task.
Revised: We start our construction by deﬁning a graph to be served as the causal graph of the constructed task.

Original: For that, we focus here on the following causal graph structures: chain , directed chain , fork , inverted fork , star , bipartite graph , directed bipartite graph , tree , polytree , and directed acyclic graph , complete graph , and random graph .
Revised: For that, we focus here on the following causal graph structures: chain , directed chain , fork , inverted fork , star , bipartite graph , directed bipartite graph , tree , polytree , and directed acyclic graph , complete graph , and random graph .

Original: For some of these structures, namely directed chain , fork , inverted fork , and complete graph the graphs are fully deﬁned by the number of nodes (modulo automorphisms).
Revised: For some of these structures, namely directed chain , fork , inverted fork , and complete graph the graphs are fully deﬁned by the number of nodes (modulo automorphisms).

Original: In other cases, we introduce randomness into the graph construction.
Revised: In other cases, we introduce randomness into the graph construction.

Original: In what fol- lows, we ﬁrst describe how we handle these cases, and then how a task with the given causal structure is constructed.
Revised: In what follows, we ﬁrst describe how we handle these cases, and then how a task with the given causal structure is constructed.

Original: Directed Bipartite Graph: A full directed bipartite graph is constructed by ﬁrst randomly partitioning the nodes into left and right and then introducing an edge from each node on the left to each node on the right.Bipartite Graph: A full
Revised: Directed Bipartite Graph: A full directed bipartite graph is constructed by ﬁrst randomly partitioning the nodes into left and right and then introducing an edge from each node on the left to each node on the right.

Original: undirected bipartite

Original: graph is

Original: con

Original: structed

Original: by

Original:  ﬁrst randomly partitioning the nodes into left and right and then introducing an edge from each node on the left to each node on the right and vice versa
Revised: Bipartite Graph: A full undirected bipartite graph is constructed by ﬁrst randomly partitioning the nodes into left and right and then introducing an edge from each node on the left to each node on the right, and vice versa.

Original: Directed Chain:
Revised: Directed Chain:

Original: A directed chain of n nodes v 1 , . .
Revised: A directed chain of n nodes v 1 , . .

Original: . , v n is created by adding the edges ( v i , v i +1 ) for each 1 ≤ i < n .
Revised: . , v n is created by adding the edges ( v i , v i +1 ) for each 1 ≤ i < n .

Original: Chain: An undirected chain of n nodes v 1 , . .
Revised: Chain: An undirected chain of n nodes v 1 , . .

Original: . , v n is created as follows.
Revised: . , v n is created as follows.

Original: For each 1 ≤ i < n , we randomly decide whether to add an edge ( v i , v i +1 ) , with probability p .
Revised: For each 1 ≤ i < n , we randomly decide whether to add an edge ( v i , v i +1 ) , with probability p .

Original: If no such edge is added, we add the edge ( v i +1 , v i ) and if the edge ( v i , v i +1 ) was added, we decide with probability p whether to add the edge ( v i +1 , v i ) .
Revised: If no such edge is added, we add the edge ( v i +1 , v i ) and if the edge ( v i , v i +1 ) was added, we decide with probability p whether to add the edge ( v i +1 , v i ) .

Original: Tree: A directed tree of n nodes v 1 , . .
Revised: Tree: A directed tree of n nodes v 1 , . .

Original: . , v n is constructed by choosing for each node v i a parent randomly out of the  nodes v 1 , . .
Revised: . , v n is constructed by choosing for each node v i a parent randomly out of the [Figure] nodes v 1 , . .

Original: , v i − 1 .
Revised: , v i − 1 .

Original: Polytree: For a polytree, we start with a tree constructed as above, and then for each edge switch its direction with probability p .
Revised: Polytree: For a polytree, we start with a tree constructed as above, and then for each edge switch its direction with probability p .

Original: Directed Acyclic Graph: A directed acyclic graph of n nodes v 1 , . .
Revised: Directed Acyclic Graph: A directed acyclic graph of n nodes v 1 , . .

Original: . , v n is constructed by choosing for each node v i at least one parent randomly out of the nodes v 1 , . .
Revised: . , v n is constructed by choosing for each node v i at least one parent randomly out of the nodes v 1 , . .

Original: , v i − 1 .
Revised: , v i − 1 .

Original: We do that by going over all the preceding nodes and deciding with probability p whether to add an edge from the preceding node to the current node.
Revised: We do that by going over all the preceding nodes and deciding with probability p whether to add an edge from the preceding node to the current node.

Original: If no edges were added, we repeat until at least one edge is added for each node (except the ﬁrst one).
Revised: If no edges were added, we repeat until at least one edge is added for each node (except the ﬁrst one).

Original: Random Graph: For each pair of nodes v i and v j we randomly decide whether to add a directed edge from v i to v j .
Revised: Random Graph: For each pair of nodes v i and v j we randomly decide whether to add a directed edge from v i to v j .

Original: Fork:
Revised: Fork:

Original: A fork is a directed tree with all non-root nodes being leafs, with their parent being the root node.
Revised: A fork is a directed tree with all non-root nodes being leafs, with their parent being the root node.

Original: A fork over nodes v 1 , . .
Revised: A fork over nodes v 1 , . .

Original: . , v n is created by adding the edges ( v 1 , v i ) for each 1 < i ≤ n .
Revised: . , v n is created by adding the edges ( v 1 , v i ) for each 1 < i ≤ n .

Original: Inverted Fork:
Revised: Inverted Fork:

Original: An inverted fork is a directed polytree with one leaf node and all non-leaf nodes being roots, with their only child node being the leaf node.
Revised: An inverted fork is a directed polytree with one leaf node and all non-leaf nodes being roots, with their only child node being the leaf node.

Original: An inverted fork over nodes v 1 , . .
Revised: An inverted fork over nodes v 1 , . .

Original: . , v n is created by adding the edges ( v i , v 1 ) for each 1 < i ≤ n .
Revised: . , v n is created by adding the edges ( v i , v 1 ) for each 1 < i ≤ n .

Original: Star: A star structure has one central node with all other nodes connected with the central node only.
Revised: Star: A star structure has one central node with all other nodes connected with the central node only.

Original: A star over nodes v 1 , . .
Revised: A star over nodes v 1 , . .

Original: . , v n is created as follows.
Revised: . , v n is created as follows.

Original: For each 1 < i ≤ n , we randomly decide whether to add an edge ( v 1 , v i ) , with probability p .
Revised: For each 1 < i ≤ n , we randomly decide whether to add an edge ( v 1 , v i ) , with probability p .

Original: If no such edge is added, we add the edge ( v i , v 1 ) and if the edge ( v 1 , v i ) was added, we decide with probability p whether to add the edge ( v i , v 1 ) .
Revised: If no such edge is added, we add the edge ( v i , v 1 ) and if the edge ( v 1 , v i ) was added, we decide with probability p whether to add the edge ( v i , v 1 ) .

Original: Complete Graph: A complete graph over nodes v 1 , . .{+E ) , number of facts n ≥ 2 |V| 1: Partition n into |V| values d v ≥ 2 such that (cid:80) v ∈V d v = n 2: F v ← {(cid:104) v, ϑ (cid:105) | 0 ≤ ϑ < d v } for all v ∈ V 3: s 
 [ v ] ← 0 for all v ∈ V 4: k ← 0 5: A ← ∅ 6: F k ← s7: while | F k | < n or E \ E A (cid:54) = ∅ do 8: k ← k +9: m k ← number of new facts for layer k 10:+}
Revised: Input: Graph G = ( V , {+E ) , number of facts n ≥ 2 |V| 1: Partition n into |V| values d v ≥ 2 such that (cid:80) v ∈V d v = n 2: F v ← {(cid:104) v, ϑ (cid:105) | 0 ≤ ϑ < d v } for all v ∈ V 3: s 
 [ v ] ← 0 for all v ∈ V 4: k ← 0 5: A ← ∅ 6: F k ← s7: while | F k | < n or E \ E A (cid:54) = ∅ do 8: k ← k +9: m k ← number of new facts for layer k 10:+}

Revised: F k , A k − 1 ← C REATE L AYER ( m k , F k − 1 , A ) 11:

Revised: A ← A ∪ A k −12: Select s ∗ ⊆

Revised: F k such that ∀ v ∈ V , | s ∗ ∩ F v | ≤ 1 and s ∗ ∩ ( F k \ F k − 1 ) (cid:54) = ∅ 13: return Π

Revised: = (cid:104)V , A, s 0 , s ∗ (cid:105) 14: function C REATE L AYER ( m , F , A ) 15:

Revised: A (cid:48) ← ∅ 16:

Revised: F (cid:48) ← F 17: while | F (cid:48) \ F | < m or ( m = 0 and E \ E A ∪ A (cid:48) (cid:54) = ∅ ) do 18: a ← C REATE A CTION 19: if E a ⊆ E then 20: if E a \ E A ∪ A (cid:48)

Revised: = ∅ and Random( p ) then 21:

Revised: Continue 22:

Revised: A (cid:48)

Revised: ← A (cid:48) ∪ { a } 23:

Revised: F (cid:48) ← F (cid:48) ∪ eﬀ ( a ) 24: return F (cid:48) , A (cid:48)

Revised: Complete Graph: A complete graph over nodes v 1 , . .

Original: . , v n is created by adding the edges ( v i , v j ) and ( v j , v i ) for all 1 ≤ i < j ≤ n .
Revised: . , v n is created by adding the edges ( v i , v j ) and ( v j , v i ) for all 1 ≤ i < j ≤ n .

Original: Figure 1 exempliﬁes selected graph structures.
Revised: Figure 1 exempliﬁes selected graph structures.

Original: Having described how a causal graph for the future planning task is constructed, we now switch to the next step, showing how to construct a planning task with that causal graph.
Revised: Having described how a causal graph for the future planning task is constructed, we now switch to the next step, showing how to construct a planning task with that causal graph.

Original: Planning Task Construction
Revised: Planning Task Construction

Original: Given a graph G =
Revised: Given a graph G =

Original: ( V , E ) and a number of facts n ≥ 2 |V| , we construct the SAS + planning task Π
Revised: ( V , E ) and a number of facts n ≥ 2 |V| , we construct the SAS + planning task Π

Original: = (cid:104)V , A, s 0 , s ∗ (cid:105) with the causal graph G as follows.
Revised: = (cid:104)V , A, s 0 , s [Equation] with the causal graph G as follows.

Original: First, we choose the domain size d v ≥ 2 for each of the multi-valued variables v ∈ V and assume w.l.o.g.
Revised: First, we choose the domain size d v ≥ 2 for each of the multi-valued variables v ∈ V and assume w.l.o.g.

Original: the values to be dom ( v ) = { 0 , . .
Revised: the values to be dom ( v ) = { 0 , . .

Original: , d v − 1 } .
Revised: , d v − 1 } .

Original: The variables represent sets of mutually exclusive facts (mutexes), and each such set corresponds to one of the two types of mutexes, namely, either exactly one or at most one of the values is true in all reachable states.
Revised: The variables represent sets of mutually exclusive facts (mutexes), and each such set corresponds to one of the two types of mutexes, namely, either exactly one or at most one of the values is true in all reachable states.

Original: We randomly decide which variables belong to which category.
Revised: We randomly decide which variables belong to which category.

Original: For the variables that represent the at-most-one case, we dedicate the last domain value to represent the case when none of the other facts are true.
Revised: For the variables that represent the at-most-one case, we dedicate the last domain value to represent the case when none of the other facts are true.

Original: Next, w.l.o.g.
Revised: Next, w.l.o.g.

Original: we assume s 

Revised: we assume s

Original: [ v ] = 0 for all v ∈ V .
Revised: [ v ] = 0 for all v ∈ V .

Original: Then, we construct the actions, in layers, while constructing the relaxed planning graph. 
Revised: Then, we construct the actions, in layers, while constructing the relaxed planning graph. Fi- b i p a r t i t e bd - b i

Original: Finally, the goal is chosen from the last fact layer of the relaxed planning graph, making sure that at least one of the chosen facts is unique to the last fact layer and that at most one fact is chosen per variable.
Revised: p a r t i t e c h a i n 0 . c h a i n 0 . c

Revised: h a i n 0 .

Revised: c

Revised: h a i n 0 .

Revised: c

Revised: o m p l e t e d a g 0 .d

Revised: a g 0 .

Revised: d a g 0 .d

Revised: a g 0 .

Revised: d - c h a i n f o r k i n v e r t e d f o r k p

Revised: o

Revised: l y t r ee 0 .p

Revised: o l y t r ee 0 .p

Revised: o l y t r ee 0 .p

Revised: o l y t r ee 0 .r

Revised: a n d o m 0 .r

Revised: a n d o m 0 .r

Revised: a n d o m 0 .r

Revised: a n d o m 0 .s

Revised: t a r 0 .s

Revised: t a r 0 .

Revised: s t a r 0 .s

Revised: t a r 0 .

Revised: t r ee      nally, the goal is chosen from the last fact layer of the relaxed planning graph, making sure that at least one of the chosen facts is unique to the last fact layer and that at most one fact is chosen per variable.

Original: In what follows, we describe how actions are constructed.
Revised: In what follows, we describe how actions are constructed.

Original: Starting with the initial state as the ﬁrst fact layer F 0 , we create actions for an action layer
Revised: Starting with the initial state as the ﬁrst fact layer F 0 , we create actions for an action layer

Original: L i by (I) selecting a subset of facts from the fact layer F i , ensuring at most one fact is selected per variable, (II) partitioning the selected set of facts into prevail condition and non-prevail precondition, and (III) choosing for all 1 the variables of the precondition facts a different value as its effect.
Revised: L i by (I) selecting a subset of facts from the fact layer F i , ensuring at most one fact is selected per variable, (II) partitioning the selected set of facts into prevail condition and non-prevail precondition, and (III) choosing for all 1 the variables of the precondition facts a different value as its effect.

Original: The constructed action is checked against the graph G , ensuring that it contributes only edges that exist in G .
Revised: The constructed action is checked against the graph G , ensuring that it contributes only edges that exist in G .

Original: If not, the action is discarded.
Revised: If not, the action is discarded.

Original: Additionally, if the constructed action does not add any new causal edges and does not achieve new facts, we randomly decide whether to keep it.
Revised: Additionally, if the constructed action does not add any new causal edges and does not achieve new facts, we randomly decide whether to keep it.

Original: The generic approach to action construction described above can be adapted to enforce particular properties.
Revised: The generic approach to action construction described above can be adapted to enforce particular properties.

Original: We discuss three such cases in detail.
Revised: We discuss three such cases in detail.

Original: (A)
Revised: (A)

Original: The ﬁrst case is enforcing the action to achieve at least one new fact.
Revised: The ﬁrst case is enforcing the action to achieve at least one new fact.

Original: For that, one can ensure in steps (I) and (II) that the precondition includes facts for some variables v ∈ V that are not fully covered by the fact layer F i (that is F v \ F i (cid:54) = ∅ ), and in step (III) to choose one of these facts F v \ F i .
Revised: For that, one can ensure in steps (I) and (II) that the precondition includes facts for some variables v ∈ V that are not fully covered by the fact layer F i (that is F v \ F i (cid:54) = ∅ ), and in step (III) to choose one of these facts F v \ F i .

Original: Note that this can be done without adding any edges to the causal graph, if a single fact is chosen in step (I).
Revised: Note that this can be done without adding any edges to the causal graph, if a single fact is chosen in step (I).

Original: (B) The second case is enforcing the preconditions to include atoms from F i \ F i − 1 , enforced in step (I).
Revised: (B) The second case is enforcing the preconditions to include atoms from F i \ F i − 1 , enforced in step (I).

Original: Input: Graph G =

Original: ( V , E ) , number of facts n ≥ 2 |V| 1: Partition n into |V| values

Original: [-d v ≥ 2 such that (cid:80) v ∈V d v = n 2: F v ← {(cid:104) v, ϑ (cid:105) | 0 ≤ ϑ < d v } for all v ∈ V 3: s 
-]
Revised: [-d v ≥ 2 such that (cid:80) v ∈V d v = n 2: F v ← {(cid:104) v, ϑ (cid:105) | 0 ≤ ϑ < d v } for all v ∈ V 3: s 
-]

Original: [ v ] ← 0 for all v ∈ V 4: k ← 0 5: A ← ∅ 6: F k ← s7: while | F k | < n or E \ E A (cid:54) = ∅ do 8: k ← k +9: m k ← number of new facts for layer k 10:

Original: F k , A k − 1 ← C REATE L AYER ( m k , F k − 1 , A ) 11:

Original: A ← A ∪ A k −12: Select s ∗ ⊆

Original: F k such that ∀ v ∈ V , | s ∗ ∩ F v | ≤ 1 and s ∗ ∩ ( F k \ F k − 1 ) (cid:54) = ∅ 13: return Π

Original: = (cid:104)V , A, s 0 , s ∗ (cid:105) 14: function C REATE L AYER ( m , F , A ) 15:

Original: A (cid:48) ← ∅ 16:

Original: F (cid:48) ← F 17: while | F (cid:48) \ F | < m or ( m = 0 and E \ E A ∪ A (cid:48) (cid:54) = ∅ ) do 18: a ← C REATE A CTION 19: if E a ⊆ E then 20: if E a \ E A ∪ A (cid:48)

Original: = ∅ and Random( p ) then 21:

Original: Continue 22:

Original: A (cid:48)

Original: ← A (cid:48) ∪ { a } 23:

Original: F (cid:48) ← F (cid:48) ∪ eﬀ ( a ) 24: return F (cid:48) , A (cid:48)

Original: (C)
Revised: (C)

Original: The third case is enforcing adding a particular edge (cid:104) v, v (cid:48) (cid:105) to the causal graph.
Revised: The third case is enforcing adding a particular edge (cid:104) v, v (cid:48) (cid:105) to the causal graph.

Original: This can be done by ensuring that (cid:104) v, ϑ (cid:105) and (cid:104) v (cid:48) , ϑ (cid:48) (cid:105) are chosen in step (I), and in step (II) at most one of these facts is chosen for the prevail condition
Revised: This can be done by ensuring that (cid:104) v, ϑ (cid:105) and (cid:104) v (cid:48) , ϑ (cid:48) (cid:105) are chosen in step (I), and in step (II) at most one of these facts is chosen for the prevail condition.

Original: We randomly independently decide whether to enforce the options (A)-(C) and whether to add edges to the causal graph.
Revised: We randomly independently decide whether to enforce the options (A)-(C) and whether to add edges to the causal graph.

Original: Note that not all combinations are always possible.
Revised: Note that not all combinations are always possible.

Original: In such cases, an action is not constructed in that iteration.
Revised: In such cases, an action is not constructed in that iteration.

Original: Each layer is constructed until a sufﬁcient number of new facts F i +1 \ F i is added.
Revised: Each layer is constructed until a sufﬁcient number of new facts F i +1 \ F i is added.

Original: The construction is stopped when all facts were achieved and all edges from G are reﬂected in the causal graph of the constructed planning task.
Revised: The construction is stopped when all facts were achieved and all edges from G are reﬂected in the causal graph of the constructed planning task.

Original: The latter is enforced in the last layer.
Revised: The latter is enforced in the last layer.

Original: The goal is then randomly chosen from the last layer according to step (I), ensuring that at least one of the facts is not achieved before the last layer, analogously to how a precondition of an action is chosen when enforcing the option (B).
Revised: The goal is then randomly chosen from the last layer according to step (I), ensuring that at least one of the facts is not achieved before the last layer, analogously to how a precondition of an action is chosen when enforcing the option (B).

Original: Algorithm 1 describes the construction of a planning task from the given graph G , where the function C REATE A CTION creates a single action, randomly choosing among the options described above.
Revised: Algorithm 1 describes the construction of a planning task from the given graph G , where the function C REATE A CTION creates a single action, randomly choosing among the options described above.

Original: Theorem 1 Given G and n , Algorithm 1 terminates in time polynomial in | G | and n and returns a planning task with the causal graph G .
Revised: Theorem 1 Given G and n , Algorithm 1 terminates in time polynomial in | G | and n and returns a planning task with the causal graph G .

Original: Proof: The proof follows from the fact that in line 18 of Algorithm 1, for some of the options for action creation must eventually hold E a ⊆ E and E a \ E A ∪ A (cid:48) (cid:54) = ∅ .
Revised: Proof: The proof follows from the fact that in line 18 of Algorithm 1, for some of the options for action creation must eventually hold E a ⊆ E and E a \ E A ∪ A (cid:48) (cid:54) = ∅ .

Original: Therefore, C REATE L AYER terminates and returns a layer with m new facts or, if m = 0 , with A (cid:48)
Revised: Therefore, C REATE L AYER terminates and returns a layer with m new facts or, if m = 0 , with A (cid:48)

Original: such that E A ∪ A (cid:48)
Revised: such that E A ∪ A (cid:48)

Original: =
Revised: =

Original: E .
Revised: E .

Original: As there are only a constant number of options, a new fact is achieved or a new causal graph edge is covered in time O (1) and therefore C REATE L AYER terminates in time O ( m + | E | ) .
Revised: As there are only a constant number of options, a new fact is achieved or a new causal graph edge is covered in time O (1) and therefore C REATE L AYER terminates in time O ( m + | E | ) .

Original: Since at least one new fact is added in each layer, Algorithm 1 terminates in time O ( n | E | ) .
Revised: Since at least one new fact is added in each layer, Algorithm 1 terminates in time O ( n | E | ) .

Original: Since the while loop in lineterminates only when E \ E A = ∅ and actions a are added to A only if E a ⊆ E , when the algorithm terminates we have E
Revised: Since the while loop in lineterminates only when E \ E A = ∅ and actions a are added to A only if E a ⊆ E , when the algorithm terminates we have E

Original: A = E , and therefore the causal graph of the returned task Π is exactly G .
Revised: A = E , and therefore the causal graph of the returned task Π is exactly G .

Original: [Equation]
Revised: [Equation]

Original: In order to create a PDDL task, the SAS + task is then translated to the STRIPS fragment of PDDL , ignoring the facts that correspond to the last value of the variables representing the at-most-one case.
Revised: In order to create a PDDL task, the SAS + task is then translated to the STRIPS fragment of PDDL , ignoring the facts that correspond to the last value of the variables representing the at-most-one case.

Original: PDDL preconditions are taken from SAS + preconditions, add effects are taken from SAS
Revised: PDDL preconditions are taken from SAS + preconditions, add effects are taken from SAS

Original: + effects, and delete effects are taken from non-prevail preconditions.
Revised: + effects, and delete effects are taken from non-prevail preconditions.

Original: Note that if the tasks are translated from STRIPS back to SAS + , there is nothing that enforces that the same mutex groups will be detected, as different planners implement different translation procedures.
Revised: Note that if the tasks are translated from STRIPS back to SAS + , there is nothing that enforces that the same mutex groups will be detected, as different planners implement different translation procedures.

Original: Thus, the causal graph structure is not necessarily preserved by translating to STRIPS and back to SAS + .
Revised: Thus, the causal graph structure is not necessarily preserved by translating to STRIPS and back to SAS + .

Original: Experimental Evaluation
Revised: Experimental Evaluation

Original: We start by constructing the benchmark set, as described in the previous section.
Revised: We start by constructing the benchmark set, as described in the previous section.

Original: Our benchmark set was generated as follows.
Revised: Our benchmark set was generated as follows.

Original: For each of the causal graph structures mentioned above, and a value in [0 . 1 , 0 . 25 , 0 . 5 , 0 . 75] for edge probability (if needed), we create a collection of tasks.
Revised: For each of the causal graph structures mentioned above, and a value in [0 . 1 , 0 . 25 , 0 . 5 , 0 . 75] for edge probability (if needed), we create a collection of tasks.

Original: This results in 27 collections in our case, with 7 causal graph structures that do not consider edge probabilities and 5 causal graph structures that do.
Revised: This results in 27 collections in our case, with 7 causal graph structures that do not consider edge probabilities and 5 causal graph structures that do.

Original: For each such collection, we generateinstances by uniformly choosing the number of atoms ( variants), variables (4 variants), goal variables (4 variants), maximum prevail size (2 variants), maximum effect size ( variants), and the upper bound on the minimum number of atoms per layer (2 variants).
Revised: For each such collection, we generateinstances by uniformly choosing the number of atoms ( variants), variables (4 variants), goal variables (4 variants), maximum prevail size (2 variants), maximum effect size ( variants), and the upper bound on the minimum number of atoms per layer (2 variants).

Original: Thus, our constructed benchmark set consists of 13824 generated planning tasks.
Revised: Thus, our constructed benchmark set consists of 13824 generated planning tasks.

Original: The benchmark set and the code for generating planning tasks according to a given causal structure will be publicly available.
Revised: The benchmark set and the code for generating planning tasks according to a given causal structure will be publicly available.

Revised: To give a general impression of typical generation time,

Revised: Figure 2 shows the mean generation time and 95% conﬁdence intervals for each collection.

Revised: It is worth mentioning that while in most collections task generation is typically quick, in some collections, such as complete and random , it can be quite time consuming.

Revised: We note that these causal structures are somewhat less interesting.

Revised: Nonetheless, we have decided to include these collections in our generated set.

Original:  Our evaluation of the constructed set aims at understanding whether the set is sufﬁciently challenging for modern cost-optimal planners.
Revised: [Table] Our evaluation of the constructed set aims at understanding whether the set is sufﬁciently challenging for modern cost-optimal planners.

Original: Therefore, we have selected the topperforming cost-optimal planners from the most recent International Planning Competition (IPC) 2018:
Revised: Therefore, we have selected the topperforming cost-optimal planners from the most recent International Planning Competition (IPC) 2018:

Original: Complementary (Franco et al. 2018), Planning-PDBs (Moraru et al.
Revised: Complementary (Franco et al. 2018), Planning-PDBs (Moraru et al.

Original: and Scorpion (Seipp 2018).
Revised: and Scorpion (Seipp 2018).

Original: We excluded the portfolio planner
Revised: We excluded the portfolio planner

Original: Delﬁ (Katz et al. 2018; Sievers et al. 2019), and included instead its top performing components: the symbolic planner S YM BA ∗ (Torralba et al. 2014) and explicit heuristic search with LM-cut heuristic (Helmert and Domsh- Collection [Table]
Revised: Delﬁ (Katz et al. 2018), and included instead its top performing components: the symbolic planner S YM BA ∗ (Torralba et al. 2014) and explicit heuristic search with LMcut heuristic (Helmert and Domshlak 2009), 2 both with hmutex detection (Alc´azar and Torralba 2015).

Original: [Table] [Table] [Table] [Table]
Revised: The planners

Original: [Table]
Revised: [Table]

Original: complete     dag 0. dag 0. dag 0. dag 0.
Revised: are run on the entire constructed benchmark set, with the timeout of 30 minutes and memory limit of 7.6GB allocated to each run.

Original: [Table] chain     fork     inverted fork     polytree 0. polytree 0. polytree 0.
Revised: The experiments were performed on Intel(R)

Original: polytree 0. random 0. random 0. random 0.
Revised: Xeon(R

Original: random 0. star 0. star 0. star 0.
Revised: CPU E machines.

Original: star 0. tree Sum (13824) LM-cut heuristic
Revised: Table 1 shows per-collection aggregated coverage comparison of the selected planners.

Original: and S YM BA ∗ planner. Bolded results indicate the best coverage in a collection and overall. lak 2009) 2 , both with h 2 mutex detection (Alc´azar and Torralba 2015).
Revised: Each task in a collection contributes a value of 1 to the coverage if it was either solved by the planner or the planner was able to prove the task to be unsolvable.

Original: The planners are run on the entire constructed benchmark set, with the timeout of 30 minutes and memory limit of 7.6GB allocated to each run. The experiments were performed on Intel(R) Xeon(R) CPU E7-8837 @2.67GHz machines. Table 1 shows per-collection coverage comparison of the selected planners. The coverage includes both solved tasks and tasks proved to be unsolvable.
Revised: Otherwise, the task contributes 0.

Original: Additionally, Table 2 depicts the number of tasks in each collection that  proved to be unsolvable.
Revised: Separately, Table 2 depicts the number of tasks in each collection that were proved to be unsolvable.

Original: Note that the tested planning systems perform very similarly in terms of unsolvability detection. Going beyond aggregated coverage results, and focusing components Delﬁ and
Revised: Note that the tested planning systems perform very similarly in terms of unsolvability detection. In contrast, when looking at tasks solved, the tested planning systems perform very differently.

Original: Collection [Table] [Table] on two planners with the lowest total time on average, Figure 2 shows the per-task total time for these planners.
Revised: Going beyond aggregated coverage results, and focusing on two planners with the lowest total time on average – LMcut and S YM BA ∗ , Figure 3 shows the per-task total time for these planners.

Original: There is no clear advantage to any of the planners.
Revised: For the tasks solved by both approaches within the time bound, there is no clear advantage to any of the planners.

Original: Looking at the timeouts, there are 2963 cases where S YM BA ∗ times outs but LM-cut does not, and 103 cases where LM-cut times outs but S YM BA ∗ does not.
Revised: Looking at the timeouts, there are 2963 cases where S YM BA ∗ times outs but LM-cut does not, andcases where LM-cut times outs but S YM BA ∗ does not.

Original: We observe that for each of the tested planners, in each of the collections, there still remains a signiﬁcant number of tasks not solved.
Revised: We observe that for each of the tested planners, in each of the collections, there still remains a signiﬁcant number of tasks not solved.

Original: Further, while some causal graph structures correspond to seemingly easier planning tasks, at least for the tested planners, there is a signiﬁcant number of tasks in each collection that were not solved by any of the tested planners: from 54 in chain 0.25 to 427 in random 0.75 , with the average of 219 tasks in a collection, 5917 tasks overall.
Revised: Further, while some causal graph structures correspond to seemingly easier planning tasks, at least for the tested planners, there is a signiﬁcant number of tasks in each collection that were not solved by any of the tested planners: from 54 in chain 0.25 to 427 in random 0.75 , with the average of 219 tasks in a collection, 5917 tasks overall.

Original: Clearly, the generated tasks are challenging for the state of the art in cost-optimal classical planning.
Revised: Clearly, the generated tasks are challenging for the state of the art in cost-optimal classical planning.

Revised: [Figure]

Original: Related Work
Revised: Related Work

Original: The idea of generating domain models as well as speciﬁc planning tasks has been explored in planning community, with a major focus on learning domain models from traces, for classical planning (e.g., (Yang, Wu, and Jiang 2007;
Revised: The idea of generating domain models as well as speciﬁc planning tasks has been explored in planning community, with a major focus on learning domain models from traces, for classical planning (e.g., (Yang, Wu, and Jiang 2007;

Original: Zhuo et al. 2010; Tian, Zhuo, and Kambhampati 2016)) and
Revised: Zhuo et al. 2010; Tian, Zhuo, and Kambhampati 2016)) and

Original: HTN planning (e.g., (Hogg, Mu˜noz-Avila, and Kuter 2008;
Revised: HTN planning (e.g., (Hogg, Mu˜noz-Avila, and Kuter 2008;

Original: Hogg, Kuter, and Mu˜noz-Avila 2010; Hogg, Mu˜noz-Avila, and Kuter 2016)).
Revised: Hogg, Kuter, and Mu˜noz-Avila 2010; Hogg, Mu˜noz-Avila, and Kuter 2016)).

Original: The work on learning domain models often assumes an existence of a complete model where the plan traces or plan examples are generated from.
Revised: The work on learning domain models often assumes an existence of a complete model where the plan traces or plan examples are generated from.

Original: Some aspects of these domain models are then learned or reconstructed from successful plan traces.
Revised: Some aspects of these domain models are then learned or reconstructed from successful plan traces.

Original: Some examples include learning action preconditions (Zhuo et al. 2009), or reﬁne incomplete action descriptions (Zhuo, Nguyen, and Kambhampati 2013).
Revised: Some examples include learning action preconditions (Zhuo et al. 2009), or reﬁne incomplete action descriptions (Zhuo, Nguyen, and Kambhampati 2013).

Original: Probably a more related to our current work is the work on generating problem instances for CSP/SAT problems (e.g., (Achlioptas et al. 2000; Xu et al. 2005)).There are also sev- [Figure] t.o.
Revised: Probably a more related to our current work is the work on generating problem instances for CSP/SAT problems (e.g., (Achlioptas et al. 2000; Xu et al. 2005)).

Original: [Figure] eral online tools/services such as the “Tough SAT Project” or “SATLIB” that generate CNF formulas encoding “difﬁcult” problems (e.g., (Yuen and Bebel 2017; Hoos and
Revised: There are also several online tools/services such as the “Tough SAT Project” or “SATLIB” that generate CNF formulas encoding “difﬁcult” problems (e.g., (Yuen and Bebel 2017; Hoos and

Original: St¨utzle 2000)).
Revised: St¨utzle 2000)).

Original: Producing hard satisﬁable instances has several advantages one of which is to advance the research ﬁeld in SAT/CSP by providing a suite of problems that can be used for evaluation of solvers.
Revised: Producing hard satisﬁable instances has several advantages one of which is to advance the research ﬁeld in SAT/CSP by providing a suite of problems that can be used for evaluation of solvers.

Original: Further, these instances can be polynomial-time reduced to STRIPS in theory, but also in practice (Porco, Machado, and Bonet 2011).
Revised: Further, these instances can be polynomial-time reduced to STRIPS in theory, but also in practice (Porco, Machado, and Bonet 2011).

Original: The authors provide a tool to translate multiple NP-complete computational problem instances (including SAT, CLIQUE, DirectedHamiltonianPath, etc.) into an NP-Complete fragment of
Revised: The authors provide a tool to translate multiple NP-complete computational problem instances (including SAT, CLIQUE, DirectedHamiltonianPath, etc.) into an NP-Complete fragment of

Original: STRIPS that they call STRIPS -1.
Revised: STRIPS that they call STRIPS -1.

Original: In that fragment, the actions are either delete-free or can be applied at most once.
Revised: In that fragment, the actions are either delete-free or can be applied at most once.

Original: While the fragment is somewhat limited, the approach can be used for creating additional benchmark sets for planning.
Revised: While the fragment is somewhat limited, the approach can be used for creating additional benchmark sets for planning.

Original: Unfortunately, the work has not yet received the attention it deserves, and the instances or the tool are not currently widely used.
Revised: Unfortunately, the work has not yet received the attention it deserves, and the instances or the tool are not currently widely used.

Original: It is worth mentioning that our suggested approach to generating random PDDL instances is a somewhat different task than generating random CNF formula, and then translating to STRIPS .
Revised: It is worth mentioning that our suggested approach to generating random PDDL instances is a somewhat different task than generating random CNF formula, and then translating to STRIPS .

Original: Our focus is on being able to control the causal structure of the generated problem, which is not possible with the aforementioned methods.
Revised: Our focus is on being able to control the causal structure of the generated problem, which is not possible with the aforementioned methods.

Original: Another highly related work is the work on random planning tasks generation for the purpose of analyzing the phase transition in classical planning (Bylander 1996; Rintanen 2004).
Revised: Another highly related work is the work on random planning tasks generation for the purpose of analyzing the phase transition in classical planning (Bylander 1996; Rintanen 2004).

Original: The authors propose a variety of models for sampling the space of STRIPS planning problem instances, exploring the possibility of phase transition at some constant ratio of the number of actions to the number of state variables.
Revised: The authors propose a variety of models for sampling the space of STRIPS planning problem instances, exploring the possibility of phase transition at some constant ratio of the number of actions to the number of state variables.

Original: These models correspond to a constrained set of problem instances, restricting the sizes of preconditions and effects, and reducing the chances of generating trivially unsolvable tasks.
Revised: These models correspond to a constrained set of problem instances, restricting the sizes of preconditions and effects, and reducing the chances of generating trivially unsolvable tasks.

Original: Unfortunately, the proposed methods for generating tasks do not yield tasks of a desired structure and it is not clear what additional restrictions can be imposed in order to obtain such tasks.
Revised: Unfortunately, the proposed methods for generating tasks do not yield tasks of a desired structure and it is not clear what additional restrictions can be imposed in order to obtain such tasks.

Original: Summary
Revised: Summary

Original: In this work, we have presented an approach that allows to generate planning tasks with the causal graph of a speciﬁc given structure.
Revised: In this work, we have presented an approach that allows to generate planning tasks with the causal graph of a speciﬁc given structure.

Original: Further, we cast these tasks into a STRIPS fragment of PDDL , allowing using as an input to any PDDL planner that supports the STRIPS fragment, as most mature planning systems do.
Revised: Further, we cast these tasks into a STRIPS fragment of PDDL , allowing using as an input to any PDDL planner that supports the STRIPS fragment, as most mature planning systems do.

Original: We have generated a benchmark set of 27 task collections characterized by the causal graph structure, with 512 tasks in each collection, summing up to 13824 ground PDDL tasks in total.
Revised: We have generated a benchmark set of 27 task collections characterized by the causal graph structure, with 512 tasks in each collection, summing up to 13824 ground PDDL tasks in total.

Original: Our experimental evaluation clearly shows that the generated benchmark set is challenging for both the heuristic search based and the symbolic search based planners.
Revised: Our experimental evaluation clearly shows that the generated benchmark set is challenging for both the heuristic search based and the symbolic search based planners.

Original: In the hope to facilitate further research and enable better comparison of planning tools, we make our tool publicly available to the planning community.
Revised: In the hope to facilitate further research and enable better comparison of planning tools, we make our tool publicly available to the planning community.

Original: For future work, we intend to explore additional structural restrictions of planning tasks, such as, e.g., k -dependence (Katz and Domshlak 2007), as well as possibly additional causal graph structures.
Revised: For future work, we intend to explore additional structural restrictions of planning tasks, such as, e.g., k -dependence (Katz and Domshlak 2007), as well as possibly additional causal graph structures.

Original: Further, we would like to investigate the phase transition in planning according to structural characterization of planning tasks.
Revised: Further, we would like to investigate the phase transition in planning according to structural characterization of planning tasks.

Original: We conjecture that phase transition might appear at different number of actions to state variables ratios for different causal graph structures.
Revised: We conjecture that phase transition might appear at different number of actions to state variables ratios for different causal graph structures.

Original: As an additional future work, we would like to explore the usage of generating planning tasks for the purpose of learning a planner selection strategy.
Revised: As an additional future work, we would like to explore the usage of generating planning tasks for the purpose of learning a planner selection strategy.

Original: Finally, we would like to explore the possibility of generating lifted PDDL tasks of a meaningful causal structure.
Revised: Finally, we would like to explore the possibility of generating lifted PDDL tasks of a meaningful causal structure.

Original: For that, we would need to understand how to characterize the ground concept of causal graph structure on a lifted level.
Revised: For that, we would need to understand how to characterize the ground concept of causal graph structure on a lifted level.