Original: A Branch-and-Cut Approach for a Mixed Integer Linear Programming Compilation of Optimal Numeric Planning
Revised: A Branch-and-Cut Approach for a Mixed Integer Linear Programming Compilation of Optimal Numeric Planning

Original: Abstract
Revised: Abstract

Original: In this paper, we consider optimal numeric planning, fo- cusing on numeric planning with simple conditions and on linear numeric planning.
Revised: In this paper, we consider optimal numeric planning, fo- cusing on numeric planning with simple conditions and on linear numeric planning.

Original: We propose a novel compilation of numeric planning to mixed-integer linear programming (MILP) and employ a branch-and-cut algorithm to lazily generate constraints.
Revised: We propose a novel compilation of numeric planning to mixed-integer linear programming (MILP) and employ a branch-and-cut algorithm to lazily generate constraints.

Original: We empirically compare the proposed method with heuristic search algorithms and other model- based approaches including an existing MILP based method.
Revised: We empirically compare the proposed method with heuristic search algorithms and other model- based approaches including an existing MILP based method.

Original: Although the new method is not competitive with heuris- tic search algorithms, compared to the existing MILP based method, it ﬁnds the optimal solutions faster in some planning domains and solves two more instances in one domain.
Revised: Although the new method is not competitive with heuris- tic search algorithms, compared to the existing MILP based method, it ﬁnds the optimal solutions faster in some planning domains and solves two more instances in one domain.

Original: Introduction
Revised: Introduction

Original: Numeric planning is an extension of classical planning where states contain numeric variables.
Revised: Numeric planning is an extension of classical planning where states contain numeric variables.

Original: As in classical planning, heuristic search methods are used to solve numeric planning tasks.
Revised: As in classical planning, heuristic search methods are used to solve numeric planning tasks.

Original: Based on the delete-relaxation in classical planning (Bonet and Geffner 2001; Hoffmann and Nebel 2001), various interval-based relaxation heuristics have been proposed for numeric planning (Hoffmann 2003; Scala et al. 2016; Aldinger and Nebel 2017; Piacentini et al.
Revised: Based on the delete-relaxation in classical planning (Bonet and Geffner 2001; Hoffmann and Nebel 2001), various interval-based relaxation heuristics have been proposed for numeric planning (Hoffmann 2003; Scala et al. 2016; Aldinger and Nebel 2017; Piacentini et al.

Original: 2018b;
Revised: 2018b;

Original: Scala et al. 2020b).
Revised: Scala et al. 2020b).

Original: In addition, other types of heuristics used in classical planning have been adapted to numeric planning such as subgoaling based heuristics (Scala et al.
Revised: In addition, other types of heuristics used in classical planning have been adapted to numeric planning such as subgoaling based heuristics (Scala et al.

Original: 2020a), landmark heuristics (Scala et al.
Revised: 2020a), landmark heuristics (Scala et al.

Original: ; Kuroiwa et al. 2021), and operator-counting heuristics (Piacentini et al.
Revised: ; Kuroiwa et al. 2021) and operator-counting heuristics (Piacentini et al.

Original: 2018b; Kuroiwa et al. 2021).
Revised: 2018b; Kuroiwa et al. 2021).

Original: In terms of optimal planning, except for the max heuristics proposed by Aldinger and Nebel (2017), admissible heuristics are limited to numeric planning with simple conditions, a restricted class of numeric planning.
Revised: In terms of optimal planning, except for the max heuristics proposed by Aldinger and Nebel (2017), admissible heuristics are limited to numeric planning with simple conditions, a restricted class of numeric planning.

Original: In contrast, model-based planners that compile numeric planning tasks to optimization problems have been proposed for optimal numeric planning.
Revised: In contrast, model-based planners that compile numeric planning tasks to optimization problems have been proposed for optimal numeric planning.

Original: Piacentini et al.
Revised: Piacentini et al.

Original: (2018a) proposed a mixed-integer linear programming (MILP) based method for linear numeric planning, a superset of numeric planning with simple conditions.
Revised: (2018a) proposed a mixed-integer linear programming (MILP) based method for linear numeric planning, a superset of numeric planning with simple conditions.

Original: An optimization modulo theories (Sebastiani and Tomasi 2015) based planner can handle optimal numeric planning with state-dependent action costs in addition to linear numeric planning (Leofante et al. 2020).
Revised: An optimization modulo theories (Sebastiani and Tomasi 2015) based planner can handle optimal numeric planning with state-dependent action costs in addition to linear numeric planning (Leofante et al. 2020).

Original: tap plant agent

Original: In this paper, following the previous research on the integer programming (IP) model for classical planning (van den  Briel, Vossen, and Kambhampati 2005), we introduce a branch-and-cut algorithm, which lazily generates constraints, to the MILP model for numeric planning.
Revised: In this paper, following the previous research on the integer programming (IP) model for classical planning (van den [Figure] Briel, Vossen, and Kambhampati 2005), we introduce a branch-and-cut algorithm, which lazily generates constraints to the MILP model for numeric planning.

Original: We empirically compare the proposed method with the existing heuristic search algorithms and model-based planners in optimal numeric planning.
Revised: We empirically compare the proposed method with the existing heuristic search algorithms and model-based planners in optimal numeric planning.

Original: Although the MILP based approaches are not competitive with the state-of-the-art heuristic search algorithms, the new MILP based method is faster and solves more instances in some numeric planning domains than the existing MILP based method.
Revised: Although the MILP based approaches are not competitive with the state-of-the-art heuristic search algorithms, the new MILP based method is faster and solves more instances in some numeric planning domains than the existing MILP based method.

Original: Motivating Example
Revised: Motivating Example

Original: In the existing MILP model for numeric planning (Piacentini et al. 2018a), decision variables represent which actions are applied at which time step, and the constraints required to achieve the goal conditions within a time horizon by applying actions starting from the initial state.
Revised: In the existing MILP model for numeric planning (Piacentini et al. 2018a), decision variables represent which actions are applied at which time step, and the constraints required to achieve the goal conditions within a time horizon by applying actions starting from the initial state.

Original: Applying multiple actions at the same time step is allowed if they do not interfere, i.e., if they can be applied in any order and the resulting state is uniquely determined regardless of the order.
Revised: Applying multiple actions at the same time step is allowed if they do not interfere, i.e., if they can be applied in any order and the resulting state is uniquely determined regardless of the order.

Original: The latter condition is necessary because the effects of actions can depend on values of numeric variables and are computed based on the state at the previous time step in the
Revised: The latter condition is necessary because the effects of actions can depend on values of numeric variables and are computed based on the state at the previous time step in the

Original: MILP model.
Revised: MILP model.

Original: We relax these conditions by allowing the application of multiple actions at the same time step if they can be applied in some order.
Revised: We relax the former condition by allowing the application of multiple actions at the same time step if they can be applied in some order.

Original: This modiﬁcation increases the number of actions that can be applied at the same time step and possibly enables the model to ﬁnd an optimal solution with a shorter time horizon.
Revised: This modiﬁcation increases the number of actions that can be applied at the same time step and possibly enables the model to ﬁnd an optimal solution with a shorter time horizon.

Original: For example, consider a numeric planning task to water a plant shown in Figure 1.
Revised: For example, consider a numeric planning task to water a plant shown in Figure 1.

Original: 1 A state consists of three numeric variables x , c , and p where x represents the position of an  action preconditions effects move right x ≤x :=
Revised: 1 A state consists of three numeric variables x , c , and p where x represents the position of an agent on a one-dimensional map, c represents the amount of water carried by the agent, and p represents the action preconditions effects move right x ≤x :=

Original: x +move left x ≥x :
Revised: x +move left x ≥x :

Original: = x −load x = 2 , c ≤c :
Revised: = x −load x = 2 , c ≤c :

Original: =
Revised: =

Original: c +pour x = 3 , c ≥c :
Revised: c +pour x = 3 , c ≥c :

Original: = c − 1 , p := p +
Revised: = c − 1 , p := p +

Original: [Figure]
Revised: [Figure]

Original: agent on a one-dimensional map, c represents the amount of water carried by the agent, and p represents the amount of water poured to the plant.
Revised: amount of water poured onto the plant.

Original: Actions move right and move left change the position of the agent, load loads water from the tap, and pour waters the plant as shown in Table 1.
Revised: Actions move right and move left change the position of the agent, load loads water from the tap, and pour waters the plant as shown in Table 1.

Original: In this example, move right and load interfere; when x = 2 , applying move right before load is impossible since move right results in x = 3 , which violates the precondition of load .
Revised: In this example, move right and load interfere; when x = 2 , applying move right before load is impossible since move right results in x = 3 , which violates the precondition of load .

Original: In the existing MILP model, these actions cannot be applied at the same time step.
Revised: In the existing MILP model, these actions cannot be applied at the same time step.

Original: However, applying move right after load is possible, and this order can be found by considering the precedence relations between actions using a graph shown in Figure 2.
Revised: However, applying move right after load is possible, and this order can be found by considering the precedence relations between actions using a graph shown in Figure 2.

Original: In our MILP model, applying interfering actions at the same time step is allowed, and the preconditions and effects of an action are computed based on the state changed by its preceding actions.
Revised: In our MILP model, applying interfering actions at the same time step is allowed, and the preconditions and effects of an action are computed based on the state changed by its preceding actions.

Original: Note that in practice the precedence relations are extracted from action descriptions that are independent of states.
Revised: Note that in practice the precedence relations are extracted from action descriptions that are independent of states.

Original: Therefore, there can exist cycles in the graph.
Revised: Therefore, there can exist cycles in the graph.

Original: For example, move right should be applied before move left when x = 0 , and move left should be applied before move right when x = 4 , so these actions form a cycle.
Revised: For example, move right should be applied before move left when x = 0 , and move left should be applied before move right when x = 4 , so these actions form a cycle.

Original: If actions form a cycle, the order in which the actions are applied cannot be determined.
Revised: If actions form a cycle, the order in which the actions are applied cannot be determined.

Original: Thus, the constraints that prohibit applying the actions in a cycle at the same time step are required.
Revised: Thus, the constraints that prohibit applying the actions in a cycle at the same time step are required.

Original: Since ﬁnding all cycles in advance is computationally expensive, we use a branch-and-cut algorithm which lazily generates the constraints when there are cycles in a found solution and ﬁnds another solution satisfying the new constraints.
Revised: Since ﬁnding all cycles in advance is computationally expensive, we use a branch-and-cut algorithm which lazily generates the constraints when there are cycles in a partial solution and ﬁnds another solution satisfying the new constraints.

Original: Suppose that x = 1 , c = 0 , and p = 0 in the initial state, and the goal condition is p ≥ 1 .
Revised: Suppose that x = 1 , c = 0 , and p = 0 in the initial state, and the goal condition is p ≥ 1 .

Original: The optimal plan is applying move right , load , move right , and pour in this order.
Revised: The optimal plan is applying move right , load , move right , and pour in this order.

Original: In the existing MILP model, since move right interferes with load and pour , at most one action can be applied at each time step.
Revised: In the existing MILP model, since move right interferes with load and pour , at most one action can be applied at each time step.

Original: Therefore, the model requires the horizon of four to ﬁnd the optimal plan.
Revised: Therefore, the model requires the horizon of four to ﬁnd the optimal plan.

Original: In contrast, in our MILP model, load can be applied after move right at the same time step.
Revised: In contrast, in our MILP model, load can be applied after move right at the same time step.

Original: The optimal plan is found with the horizon of three where move right is at the ﬁrst time step, load and move right are at the second time step, and pour is at the third time step.
Revised: The optimal plan is found with the horizon of three where move right is at the ﬁrst time step, load and move right are at the second time step, and pour is at the third time step.

Original: During the search, if a found solution applies move left and move right at the same time step, the constraints that prohibit applying the two actions at the same time step are added.
Revised: During the search, if a found solution applies move left and move right at the same time step, the constraints that prohibit applying the two actions at the same time step are added.

Original: Notation and Preliminaries
Revised: Notation and Preliminaries

Original: We consider a subset of numeric planning tasks deﬁned in
Revised: We consider a subset of numeric planning tasks deﬁned in

Original: PDDL2.1 level 2 (Fox and Long 2003).
Revised: PDDL2.1 level 2 (Fox and Long 2003).

Original: A numeric planning task is deﬁned as a 5-tuple (cid:104)F p , N , A , s I , G (cid:105) where F p is a set of propositions, N is a set of numeric variables, A is a set of actions, s I is the initial state, and G is a set of goal conditions.
Revised: A numeric planning task is deﬁned as a 5-tuple (cid:104)F p , N , A , s I , G (cid:105) where F p is a set of propositions, N is a set of numeric variables, A is a set of actions, s I is the initial state, and G is a set of goal conditions.

Original: A state s is a tuple (cid:104) s p , s n (cid:105) where s p ⊆
Revised: A state s is a tuple (cid:104) s p , s n (cid:105) where s p ⊆

Original: F p is a set of propositions and s n is a value assignment to numeric variables.
Revised: F p is a set of propositions and s n is a value assignment to numeric variables.

Original: The value of v ∈ N in s is denoted by s [ v ] .
Revised: The value of v ∈ N in s is denoted by s [ v ] .

Original: A numeric condition ψ is represented as
Revised: A numeric condition ψ is represented as

Original: [Equation]
Revised: [Equation]

Original: where N ( ψ ) ⊆
Revised: where N ( ψ ) ⊆

Original: N , w ψ 0 ∈ Q , ∀ v ∈ N ( ψ ) , w ψv ∈ Q \ { 0 } , and (cid:68) ∈ {≥ , > } .
Revised: N , w ψ 0 ∈ Q , ∀ v ∈ N ( ψ ) , w ψv ∈ Q \ { 0 } , and (cid:68) ∈ {≥ , > } .

Original: A state s satisﬁes ψ if (cid:88) v 
Revised: A state s satisﬁes ψ if (cid:88) v ∈N

Original: [Equation]
Revised: [Equation]

Original: w

Original: [Equation]

Original: [Equation]

Original: We denote this by s | = ψ .
Revised: We denote this by s | = ψ .

Original: For a set of numeric conditions ˆΨ , we say s | = ˆΨ if ∀ ψ ∈ ˆΨ , s | = ψ .
Revised: For a set of numeric conditions ˆΨ , we say s | = ˆΨ if ∀ ψ ∈ ˆΨ , s | = ψ .

Original: G is deﬁned as a tuple (cid:104) G p , G n (cid:105) where G p is a set of propositions and G n is a set of numeric conditions.
Revised: G is deﬁned as a tuple (cid:104) G p , G n (cid:105) where G p is a set of propositions and G n is a set of numeric conditions.

Original: s is a goal state if G p ⊆ s p and s | = G n .
Revised: s is a goal state if G p ⊆ s p and s | = G n .

Original: An action a ∈ A is a triplet (cid:104) pre ( a ) , eﬀ ( a ) , cost ( a ) (cid:105) where pre ( a ) is a set of preconditions, eﬀ ( a ) is a set of effects, and cost ( a ) ∈ R
Revised: An action a ∈ A is a triplet (cid:104) pre ( a ) , eﬀ ( a ) , cost ( a ) (cid:105) where pre ( a ) is a set of preconditions, eﬀ ( a ) is a set of effects, and cost ( a ) ∈ R

Original: +0 is the cost of a .
Revised: +0 is the cost of a .

Original: pre ( a ) is deﬁned as a tuple (cid:104) pre p ( a ) , pre n ( a ) (cid:105) where pre p ( a ) is a set of propositions and pre n ( a ) is a set of numeric conditions.
Revised: pre ( a ) is deﬁned as a tuple (cid:104) pre p ( a ) , pre n ( a ) (cid:105) where pre p ( a ) is a set of propositions and pre n ( a ) is a set of numeric conditions.

Original: Action a is applicable in s if pre p ( a ) ⊆
Revised: Action a is applicable in s if pre p ( a ) ⊆

Original: s p and s | = pre n ( a ) , and we denoted this by s | = pre ( a ) .
Revised: s p and s | = pre n ( a ) , and we denote this by s | = pre ( a ) .

Original: By abuse of notation, we say v ∈ pre n ( a ) if ∃ ψ ∈ pre n ( a ) , v ∈ N ( ψ ) .
Revised: By abuse of notation, we say v ∈ pre n ( a ) if ∃ ψ ∈ pre n ( a ) , v ∈ N ( ψ ) .

Original: eﬀ ( a ) is deﬁned as a triplet (cid:104) add ( a ) , del ( a ) , num ( a ) (cid:105) where add ( a ) and del ( a ) are sets of propositions.
Revised: eﬀ ( a ) is deﬁned as a triplet (cid:104) add ( a ) , del ( a ) , num ( a ) (cid:105) where add ( a ) and del ( a ) are sets of propositions.

Original: num ( a ) is a set of numeric effects v :=
Revised: num ( a ) is a set of numeric effects v :=

Original: ξ where ξ is a linear combination of numeric variables, i.e.,
Revised: ξ where ξ is a linear combination of numeric variables, i.e.,

Original: [Equation]
Revised: [Equation]

Original: where N ( ξ ) ⊆
Revised: where N ( ξ ) ⊆

Original: N , k v,a ∈ Q , and ∀ u ∈ N ( ξ ) , k v,au ∈ Q \ { 0 } .
Revised: N , k v,a ∈ Q , and ∀ u ∈ N ( ξ ) , k v,au ∈ Q \ { 0 } .

Original: A concrete value of ξ in s is deﬁned as follows:
Revised: A concrete value of ξ in s is deﬁned as follows:

Original: [Equation]
Revised: [Equation]

Original: + k v,a .

Original: Let lhs ( a ) =
Revised: Let lhs ( a ) =

Original: { v | ( v := ξ ) ∈ num ( a ) } and rhs ( a ) =
Revised: { v | ( v := ξ ) ∈ num ( a ) } and rhs ( a ) =

Original: { v | ( u := ξ ) ∈ num ( a ) , v ∈ N ( ξ ) } .
Revised: { v | ( u := ξ ) ∈ num ( a ) , v ∈ N ( ξ ) } .

Original: When a is applied in s , s transitions to s [[ a ]] = (cid:104) s
Revised: When a is applied in s , s transitions to s [[ a ]] = (cid:104) s

Original: [[ a ]] p , s [[ a ]] n (cid:105) where s [[ a ]] p = s p ∪ add ( a ) \ del ( a ) and s [[ a ]] n is a value assignment such that s [[ a ]][ v ] = ξ [ s ] if v ∈ lhs ( a ) and s [[ a ]][ v ] =
Revised: [[ a ]] p , s [[ a ]] n (cid:105) where s [[ a ]] p = s p \ del ( a ) ∪ add ( a ) and s [[ a ]] n is a value assignment such that s [[ a ]][ v ] = ξ [ s ] if v ∈ lhs ( a ) and s [[ a ]][ v ] =

Original: s [ v ] if v / ∈ lhs ( a ) .
Revised: s [ v ] if v / ∈ lhs ( a ) .

Original: For action a , we assume that add ( a ) ∩ del ( a ) = ∅ and numeric variable v is changed by at most one effect in num ( a ) .
Revised: For action a , we assume that add ( a ) ∩ del ( a ) = ∅ and numeric variable v is changed by at most one effect in num ( a ) .

Original: An s -plan is a sequence of actions which can be sequentially applied from s to make s transition to a goal state.
Revised: An s -plan is a sequence of actions which can be sequentially applied from s to make s transition to a goal state.

Original: A solution for a numeric planning task is an s I -plan, and an s I -plan is called a plan for the numeric planning task.
Revised: A solution for a numeric planning task is an s I -plan, and an s I -plan is called a plan for the numeric planning task.

Original: The cost of s -plan π = (cid:104) a 1 , ..., a n (cid:105) is deﬁned as cost ( π ) =
Revised: The cost of s -plan π = (cid:104) a 1 , ..., a n (cid:105) is deﬁned as cost ( π ) =

Original: cost ( a 1 )+ ... + cost ( a n ) .
Revised: cost ( a 1 )+ ... + cost ( a n ) .

Original: Given a numeric planning task, an optimal planning problem is to ﬁnd an optimal plan , a plan for the task which minimizes the cost.
Revised: Given a numeric planning task, an optimal planning problem is to ﬁnd an optimal plan , a plan for the task which minimizes the cost.

Original: An effect ( v := ξ ) is called a simple effect if N ( ξ ) = { v } and k v,av = 1 , i.e., ξ = v + k v,a .
Revised: An effect ( v := ξ ) is called a simple effect if N ( ξ ) = { v } and k v,av = 1 , i.e., ξ = v + k v,a .

Original: We denote a set of simple effects of a by num s ( a ) and a set of actions which have simple effects on v by se ( v ) .
Revised: We denote a set of simple effects of a by num s ( a ) and a set of actions which have simple effects on v by se ( v ) .

Original: In contrast, we call the other effects linear effects .
Revised: In contrast, we call the other effects linear effects .

Original: We denote a set of linear effects of a by num l ( a ) and a set of actions which have linear effects on v by le ( v ) .
Revised: We denote a set of linear effects of a by num l ( a ) and a set of actions which have linear effects on v by le ( v ) .

Original: We deﬁne lhs l ( a )
Revised: We deﬁne lhs l ( a )

Original: = { v | ( v := ξ ) ∈
Revised: = { v | ( v := ξ ) ∈

Original: num l ( a ) } and rhs l ( a ) =
Revised: num l ( a ) } and rhs l ( a ) =

Original: { v | ( u := ξ ) ∈
Revised: { v | ( u := ξ ) ∈

Original: num l ( a ) , v ∈ N ( ξ ) } .
Revised: num l ( a ) , v ∈ N ( ξ ) } .

Original: If N = ∅ in a planning task, it is called a classical planning task.
Revised: If N = ∅ in a planning task, it is called a classical planning task.

Original: Particularly in the formalism used in this paper, the classical planning task is called a STRIPS task (Fikes and Nilsson 1971).
Revised: Particularly in the formalism used in this paper, the classical planning task is called a STRIPS task (Fikes and Nilsson 1971).

Original: If all actions have only simple effects, the task is a numeric planning task with simple conditions ( SCT ).
Revised: If all actions have only simple effects, the task is a numeric planning task with simple conditions ( SCT ).

Original: If at least one action has linear effects, the task is a linear numeric planning task ( LT ).
Revised: If at least one action has linear effects, the task is a linear numeric planning task ( LT ).

Original: A heuristic h is a function which maps state s to heuristic value h ( s ) ∈ R +0 .
Revised: A heuristic h is a function which maps state s to heuristic value h ( s ) ∈ R +0 .

Original: h is admissible if h ( s ) is less than or equal to the optimal cost of s -plan for all state s .
Revised: h is admissible if h ( s ) is less than or equal to the optimal cost of s -plan for all state s .

Original: Background State-Change IP Model for STRIPS
Revised: Background State-Change IP Model for STRIPS

Original: In the state-change IP model for STRIPS (Vossen et al.
Revised: In the state-change IP model for STRIPS (Vossen et al.

Original: , starting from the initial state, a state is changed by actions applied at multiple time steps, and decision variable x a,t indicates whether a is applied at time step t .
Revised: , starting from the initial state, a state is changed by actions applied at multiple time steps, and decision variable x a,t indicates whether a is applied at time step t .

Original: Let s t denote the state at time step t .
Revised: Let s t denote the state at time step t .

Original: s 

Revised: s

Original: = s I .
Revised: = s I .

Original: a is applied in s t if x a,t = 1 , and s t transitions to s t +1 .
Revised: a is applied in s t if x a,t = 1 , and s t transitions to s t +1 .

Original: The objective is to minimize the cost of the planas follows:
Revised: The objective is to minimize the cost of the plan as follows:

Original: [Equation]
Revised: [Equation]

Original: where T is a set of time steps deﬁned as T = { 0 , ..., T − 1 } and T is the time horizon.
Revised: where T is a set of time steps deﬁned as T = { 0 , ..., T − 1 } and T is the time horizon.

Original: Multiple actions can be applied at the same time step if the  order in which actions are applied does not affect the result.
Revised: Multiple actions can be applied at the same time step if the actions do not interfere, i.e., the order in which actions are applied does not affect the result.

Original: In other words, a and b can be applied in s at the same time step if s [[ a ]] | = pre ( b ) , s [[ b ]] | = pre ( a ) , and s [[ a ]]
Revised: In other words, a and b can be applied in s at the same time step if s [[ a ]] | = pre ( b ) , s [[ b ]] | = pre ( a ) , and s [[ a ]]

Original: [[ b ]] = s [[ b ]]
Revised: [[ b ]] = s [[ b ]]

Original: [[ a ]] .
Revised: [[ a ]] .

Original: This is ensured by the following constraint:
Revised: This is ensured by the following constraint:

Original: [Equation]
Revised: [Equation]

Original: where 
Revised: where interfering ( a

Original: [Equation]
Revised: [Equation]

Original: There are additional decision variables representing the change of propositions.
Revised: There are additional decision variables representing the change of propositions.

Original: [Equation]
Revised: [Equation]

Original: where ˜ T
Revised: where ˜ T

Original: =
Revised: =

Original: T ∪ { T } .
Revised: T ∪ { T } .

Original: y ap,t indicates that p is added to the state at time step t .

Original: y pap,t indicates that p is required as a precondition and not deleted from the state by actions applied at t − 1 .

Original: y pdp,t indicates that p is required as a precondition and deleted from the state by an action applied at t − 1 .

Original: y mp,t indicates that p exists in s t − 1 , is not required, and is not deleted from the state by actions applied at t − 1 .

Original: The constraints over these variables are deﬁned as follows:
Revised: The constraints over these variables are deﬁned as follows:

Original: [Equation]
Revised: [Equation]

Original: where 
Revised: where pnd

Original: [Equation]
Revised: [Equation]

Original: and (10) specify the initial state.
Revised: del [Equation] ( p ) = { a ∈ A

Original: Constraint (11) ensures that the goal condition is satisﬁed in s T .
Revised: [Equation] p [Equation] ∈ pre ( a )

Original: Constraints (12)-(16) enforce preconditions and effects of actions.
Revised: [Equation] p ∈ add ( a ) [Equation] pd ( p ) =

Original:  Constraints (17) and (18) prevent applications of interfering actions  at the same time step with Constraints (3).
Revised: { a ∈ A | p ∈ pre ( a ) , p ∈ del ( a ) } . With Constraints (12) and (15), y pap,t indicates that p was required as a precondition by actions applied at t − 1 and remains in s t . With Constraints (13) and (16), y ap,t indicates that p ∈ s t because p is added by actions applied at t − 1 . With Constraint (14), y pdp,t indicates that p ∈ s t − 1 but p / ∈ s t because p is deleted by an action applied at t − 1 .

Original:  Constraint (19) ensures that the propositions  in s t are propagated to s t  +1  . 
Revised: y mp,t indicates that p existed in s t − 1 , was not required by actions applied at t − 1 , and remains in s t . Constraint (19) ensures that the propositions required to be satisﬁed in s t are satisﬁed; p is required in s t if either of y pap,t +1 , y mp,t +1 , or y pdp,t +1 is equal to 1 , and p is satisﬁed in s t if either of y ap,t , y pap,t , or y mp,t is equal to 1 . Constraints (9) and (10) specify the initial state, and Constraint (11) ensures that the goal condition is satisﬁed in s T . Constraints (17) and (18) prevent applications of interfering actions at the same time step with Constraints (3).

Original: Branch-and-Cut for STRIPS
Revised: Branch-and-Cut for STRIPS

Original: A branch-and-cut framework for classical planning is originally proposed for SAS+ (B¨ackstr¨om and Nebel 1995), another formalism of classical planning (van den Briel, Vossen, and Kambhampati 2005).
Revised: A branch-and-cut framework for classical planning (van den Briel, Vossen, and Kambhampati 2005) was originally proposed for SAS+ (B¨ackstr¨om and Nebel 1995), another formalism of classical planning.

Original: Since we use STRIPS formalism, we adapt the framework to STRIPS.
Revised: Since we use STRIPS formalism, we adapt the framework to STRIPS.

Original: In the state-change IP model, if action a is applied at t and p ∈ pre p ( a ) , action b with p ∈ del ( b ) cannot be applied at t .
Revised: In the state-change IP model, if action a is applied at t and p ∈ pre p ( a ) , action b with p ∈ del ( b ) cannot be applied at t .

Original: However, in fact, we can apply b after a at t .
Revised: However, in fact, we can apply b after a at t .

Original: Similarly, if p is not included in s t but action b with p ∈ add ( b ) is applied at t , a can be applied after b .
Revised: Similarly, if p is not included in s t but action b with p ∈ add ( b ) is applied at t , a can be applied after b .

Original: Such precedence relations between actions are represented by  graph (cid:104) V, E (cid:105) where the set of nodes is deﬁned as V
Revised: Such precedence relations between actions are represented by action precedence graph (cid:104) V, E (cid:105) where the set of nodes is deﬁned as V

Original: = A and the set of edges is deﬁned as
Revised: = A and the set of edges is deﬁned as

Original: [Equation]
Revised: [Equation]

Original: ∪ [Equation] If actions do not form cycles in (cid:104) V, E (cid:105) , they can be applied at the same time step in some order.
Revised: If actions do not form cycles in (cid:104) V, E (cid:105) , they can be applied at the same time step in some order.

Original: This can be ensured by the following cycle elimination constraints:
Revised: This can be ensured by the following cycle elimination constraints:

Original: [Equation]
Revised: [Equation]

Revised: for all cycles C in (cid:104) V, E (cid:105) , ∀ t ∈ T

Revised: [Equation]

Original: where V ( C ) is the set of nodes in cycle C .
Revised: where V ( C ) is the set of nodes in cycle C .

Original: Since the number of cycles is exponential in | V | , these constraints are lazily generated by a branch-and-cut algorithm.
Revised: Since the number of cycles is exponential in | V | , these constraints are lazily generated by a branch-and-cut algorithm.

Original: Given a solution, cycles are extracted by the following callback procedure (van den Briel, Vossen, and Kambhampati 2005):
Revised: Given a solution, cycles are extracted by the following callback procedure (van den Briel, Vossen, and Kambhampati 2005):

Original: Determine the subgraph (cid:104) V t , E t (cid:105) for time step t consisting of all actions with x a,t > 0 .
Revised: Determine the subgraph (cid:104) V t , E t (cid:105) for time step t consisting of all actions with x a,t > 0 .

Original: For each edge ( a, b ) ∈ E t , deﬁne the weight c a,b := x a,t + x b,t − 1 . 3.
Revised: For each edge ( a, b ) ∈ E t , deﬁne the weight c a,b := x a,t + x b,t − 1 . 3.

Original: Using the Floyd-Warshall algorithm, determine the shortest path distance d a,b for each pair of nodes a ∈ V t and b ∈ V t \ { a } using weight ¯ c a,b := 1 − c a,b . 4.
Revised: Using the Floyd-Warshall algorithm, determine the shortest path distance d a,b for each pair of nodes a ∈ V t and b ∈ V t \ { a } using weight ¯ c a,b := 1 − c a, b If d

Revised: a,

Revised: b

Original: If d a,b − c b,a <0 , there is acycle containing ( b, a ) .
Revised: − c b,a < , there is a

Original:  With the cycle elimination constraints, Constraint (15) is replaced with the following:
Revised: cycle containing ( b, a ) With the cycle elimination constraints, Constraint (15) is replaced with Constraint (22), which allows that precondition p of action a applied at t is added to or deleted from s t by other actions applied at t .

Original: [Equation]
Revised: [Equation]

Original: The deﬁnition of mutex ( a ) in Equation (4) is also relaxed as follows:
Revised: The deﬁnition of interfering ( a ) in Equation (4) is also relaxed as follows:

Original: [Equation]
Revised: [Equation]

Original: This modiﬁcation increases the number of pairs of actions that can be applied at the same time step and possibly reduces the number of time steps required to ﬁnd a plan.
Revised: This modiﬁcation increases the number of pairs of actions that can be applied at the same time step and possibly reduces the number of time steps required to ﬁnd a plan.

Revised: The branch-and-cut approach is similar to ∃ -step encoding of planning as satisﬁability (Wehrle and Rintanen 2007), where interfering actions can be applied at the same time step if they can be applied in some order.

Revised: In ∃ -step encoding, interfering actions are represented by the disabling-enabling graph, a directed graph that is similar to the action precedence graph but considers only interference in reachable states.

Revised: While the branch-and-cut approach prohibits the simultaneous application of actions that form a cycle in the action precedence graph, ∃ -step encoding allows it by imposing a ﬁxed ordering on actions in all strongly connected components of the disabling-enabling graph.

Revised: Using a ﬁxed ordering in an IP model is an interesting topic for future work.

Original: MILP Model for Numeric Planning
Revised: MILP Model for Numeric Planning

Original: Recent research has extended the state-change IP model for
Revised: Recent research has extended the state-change IP model for

Original: STRIPS to numeric planning (Piacentini et al. 2018a).
Revised: STRIPS to numeric planning (Piacentini et al. 2018a).

Original: The model has additional decision variable y vt , which represents the value of v ∈ N in s t .
Revised: The model has additional decision variable y vt , which represents the value of v ∈ N in s t .

Original: [Equation]
Revised: [Equation]

Original: For the numeric variables in the initial state,
Revised: For the numeric variables in the initial state,

Original: [Equation]
Revised: [Equation]

Original: For the numeric goal conditions,
Revised: For the numeric goal conditions,

Original: [Equation]
Revised: [Equation]

Original: For the numeric preconditions of actions,(cid:88)
Revised: For the numeric preconditions of actions,

Original: [Equation]
Revised: [Equation]

Original: [Equation] where m ψ,t is the lower bound of the left-hand side.
Revised: where m ψ,t is the lower bound of the left-hand side computed by Equation (34).

Original: For the numeric effects,
Revised: For the numeric effects,

Original: [Equation]
Revised: [Equation]

Original: where M step v,t +1 and m step v,t +1 are upper and lower bounds of y vt [Equation]
Revised: where M step v,t +1 and m step v,t +1 are upper and lower bounds of y vt +1 − y vt computed by Equations (35) and (36), and

Original: y vt , and M av,t [-+
-] and m av,t +1 are upper and lower bounds of y vt [Equation]
Revised: M av,t [-+
-]+1 and m a v,t +1 are upper and lower bounds of y vt +1 − k v,a − (cid:80) u ∈N ( ξ ) k v,au y ut computed by Equations (40) and (41).

Original: 28) and (29) correspond to simple effects, and Constraint (30) and (31) correspond to linear effects.
Revised: Constraints (28) and (29) correspond to simple effects, and Constraints (30) and (31) correspond to linear effects.

Original: Considering numeric preconditions and effects, Equation (4) is modiﬁed as follows:
Revised: Considering numeric preconditions and effects, Equation (4) is modiﬁed as follows:

Original: [Equation]
Revised: [Equation]

Original: Equation (32) is used in the original paper (Piacentini et al.
Revised: Equation (32) is used in the original paper (Piacentini et al.

Original: 2018a)
Revised: 2018a)

Original: but is unnecessarily strict; when b is applicable in s , if a has only simple effects on ∀ v ∈ pre n ( b ) and the net effects of a on ∀ ψ ∈ pre n ( b ) are positive, b is also applicable in s [[ a ]] .
Revised: but is unnecessarily strict; when b is applicable in s , if a has only simple effects on ∀ v ∈ pre n ( b ) and the net effects of a on ∀ ψ ∈ pre n ( b ) are positive, b is also applicable in s [[ a ]] .

Original: Using this fact, we use the following equation instead of Equation (32).
Revised: Using this fact, we use the following equation instead of Equation (32).

Original: mutex ( a ) = { b ∈ A \ { a } | del ( a ) ∩ ( add ( b ) ∪ pre p ( b )) (cid:54) = ∅} ∪ { b ∈ A \ { a } | ∃ ψ ∈ pre n ( b ) , net ( a, ψ ) < 0 } ∪ { b ∈
Revised: [Equation]

Original: A \ { a } | lhs ( a ) ∩ rhs l ( b ) (cid:54) = ∅} (33) where net ( a, ψ ) =
Revised: where net ( a, ψ ) =

Original: (cid:80) v ∈N ( ψ ) w ψv k va + w ψ 

Revised: (cid:80) v ∈N ( ψ ) w ψv k va + w ψ

Original: if a has only simple effects on N ( ψ ) , net ( a, ψ ) =
Revised: if a has only simple effects on N ( ψ ) , net ( a, ψ ) =

Original: if a has no effect on
Revised: if a has no effect on

Original: N ( ψ ) , and net ( a, ψ ) =
Revised: N ( ψ ) , and net ( a, ψ ) =

Original: −∞ otherwise since linear effects change values depending on the state.
Revised: −∞ otherwise since linear effects change values depending on the state.

Original: Big-M Values Let M v,t and m v,t be upper and lower bounds of y v t .
Revised: Values Let M v,t and m v,t be upper and lower bounds of y vt .

Original: The big-M value in Constraint (27), m ψ,t , is computed as follows:
Revised: The big-M value in Constraint (27), m ψ,t , is computed as follows:

Original: [Equation]
Revised: [Equation]

Original: where N ( ψ ) + = { v ∈ N ( ψ ) | w ψv > 0 } and N ( ψ ) − = { v ∈ N ( ψ ) | w ψv < 0 } .
Revised: where N ( ψ ) + = { v ∈ N ( ψ ) | w ψv > 0 } and N ( ψ ) − = { v ∈ N ( ψ ) | w ψv < 0 } .

Original: M step v,t and m step v,t in Constraints [Equation] 28) and (29) are computed as follows:
Revised: M step v,t and m step v,t in Constraints (28) and (29) are computed as follows:

Original: [Equation]
Revised: [Equation]

Original: Finally, M av,t and m av,t in Constraints (30) and (31) are computed as follows:
Revised: Finally, M av,t and m av,t in Constraints (30) and (31) are computed as follows:

Original: [Equation]
Revised: [Equation]

Original:  where N ( ξ ) + = { u ∈ N ( ξ ) | k v,au > 0 } and N ( ξ ) − = { u ∈ N ( ξ ) | k v,au < 0 } 
Revised: (38) where N ( ξ ) + = { u ∈ N ( ξ ) | k v,au > 0 } and N ( ξ ) − = { u ∈ N ( ξ ) | k v,au < 0 } .

Original: M v,t and m v,t are computed through the following equations:
Revised: M v,t and m v,t are computed through the following equations:

Original: [Equation]
Revised: [Equation]

Original: [Equation]

Original: [Equation]

Original: t [Equation] [Equation] where se + ( v ) = { a ∈ se ( v ) | k v,a > 0 } and se − ( v ) =
Revised: 43) where se + ( v ) = { a ∈ se ( v ) | k v,a > 0 } and se − ( v ) =

Original: { a ∈ se ( v ) | k v,a < 0 } .
Revised: { a ∈ se ( v ) | k v,a < 0 } .

Original: Landmark Constraints A fact landmark is a proposition that is added by all plans, and an action landmark is an action that is applied by all plans (Hoffmann, Porteous, and Sebastia 2004).
Revised: Landmark Constraints A fact landmark is a proposition that is added by all plans, and an action landmark is an action that is applied by all plans (Hoffmann, Porteous, and Sebastia 2004).

Original: Let F L be a set of fact landmarks and A L be a set of action landmarks.
Revised: Let F L be a set of fact landmarks and A L be a set of action landmarks.

Original: In the MILP compilation, the following valid inequalities are used (Piacentini et al. 2018a).
Revised: In the MILP compilation, the following valid inequalities are used (Piacentini et al. 2018a).

Original: [Equation]
Revised: [Equation]

Original: We extract fact and action landmarks in SCT s using the algorithm proposed by Scala et al.
Revised: We extract fact and action landmarks in SCT s using the algorithm proposed by Scala et al.

Original: In LT s, we do not use these constraints.
Revised: In LT s, we do not use these constraints.

Original: Relevance Constraints In STRIPS, action a is relevant if ∃ p ∈ add ( a ) , p ∈ G p or ∃ p ∈ pre p ( b ) where b is a relevant action (Imai and Fukunaga 2015).
Revised: Relevance Constraints In STRIPS, action a is relevant if ∃ p ∈ add ( a ) , p ∈ G p or ∃ p ∈ pre p ( b ) where b is a relevant action (Imai and Fukunaga 2015).

Original: In numeric planning, in addition to the original condition, a is relevant if ∃ ψ ∈ G n , net ( a, ψ ) > 0 , ∃ ψ ∈ pre n ( b ) , net ( a, ψ ) > 0 , ∃ v ∈ pre n ( b ) , a ∈ le ( v ) , or ∃ v ∈ rhs l ( b ) , a ∈ se [Equation] v ) ∪ le 
Revised: In numeric planning, in addition to the original condition, a is relevant if ∃ ψ ∈ G n : net ( a, ψ ) > 0 , ∃ ψ ∈ pre n ( b ) : net ( a, ψ ) > 0 , ∃ v ∈ pre n ( b ) : a ∈ le ( v ) , or ∃ v ∈ rhs l ( b ) : a ∈ se ( v ) ∪ le ( v ) where b is a relevant action (Piacentini et al. 2018b).

Original: [Equation]

Original: v ) where b is a relevant action (Piacentini et al. 2018b).

Original: The following valid equations are used in the MILP compilation (Piacentini et al. 2018a).
Revised: The following valid equations are used in the MILP compilation (Piacentini et al. 2018a).

Original: [Equation]
Revised: [Equation]

Original: Iterative Time Horizon Allocation
Revised: Iterative Time Horizon Allocation

Original: To ﬁnd an optimal plan, the iterative time horizon allocation method is proposed (Piacentini et al. 2018a).
Revised: To ﬁnd an optimal plan, the iterative time horizon allocation method is proposed (Piacentini et al. 2018a).

Original: Suppose that plan π ∗ T is found with horizon T .
Revised: Suppose that plan π ∗ T is found with horizon T .

Original: If cost ( π ∗ T ) =
Revised: If cost ( π ∗ T ) =

Original: l where l is a known lower bound of the optimal cost, π ∗ T is optimal.
Revised: l where l is a known lower bound of the optimal cost, π ∗ T is optimal.

Original: Given admissible heuristic h , h
Revised: Given admissible heuristic h , h

Original: ( s I ) can be used as the lower bound.
Revised: ( s I ) can be used as the lower bound.

Original: If cost ( π ∗ T ) ≤ T · min a ∈A cost ( a ) , π ∗ T is optimal because the right-hand side is the lower bound of the cost of plans with horizon T (cid:48) ≥ T .
Revised: If cost ( π ∗ T ) ≤ T · min a ∈A cost ( a ) , π ∗ T is optimal because the right-hand side is the lower bound of the cost of plans with horizon T (cid:48) ≥ T .

Original: Otherwise, when min a ∈A cost ( a ) > 0 , solving the MILP model with horizon ˆ T = cost ( π ∗ T ) / min a ∈A cost ( a ) gives us an optimal plan since ˆ T is the upper bound of time steps required by an optimal plan.
Revised: Otherwise, when min a ∈A cost ( a ) > 0 , solving the MILP model with horizon ˆ T = cost ( π ∗ T ) / min a ∈A cost ( a ) gives us an optimal plan since ˆ T is the upper bound of time steps required by an optimal plan.

Original: When solving the MILP model with ˆ T , the following additional constraints are added:
Revised: When solving the MILP model with ˆ T , the following additional constraints are added:

Original: [Equation]
Revised: [Equation]

Original: The ﬁrst constraint ensures that at most one action is applied at each time step, and the second constraint breaks the symmetries caused by time steps where no action is applied.
Revised: The ﬁrst constraint ensures that at most one action is applied at each time step, and the second constraint breaks the symmetries caused by time steps where no action is applied.

Original: Note that this method is not applicable in planning tasks with min a ∈A cost ( a ) = 0 .
Revised: Note that this method is not applicable in planning tasks with min a ∈A cost ( a ) = 0 .

Original: The MILP based method starts from some T , increments T by one if the model is infeasible, uses ˆ
Revised: The MILP based method starts from some T , increments T by one if the model is infeasible, uses ˆ

Original: T if a plan is found but its optimality is not guaranteed, and terminates when the optimal plan is found.
Revised: T if a plan is found but its optimality is not guaranteed, and terminates when the optimal plan is found.

Original: Branch-and-Cut for Numeric Planning
Revised: Branch-and-Cut for Numeric Planning

Original: Following the branch-and-cut framework for classical planning, we introduce precedence relations between actions using graph (cid:104) V, E (cid:105) .
Revised: Following the branch-and-cut framework for classical planning, we introduce precedence relations between actions using graph (cid:104) V, E (cid:105) .

Original: Suppose that (cid:104) V, E (cid:105) is given.
Revised: Suppose that (cid:104) V, E (cid:105) is given.

Original: Even when a is not applicable in s t , it may be applicable at t if b is applied at t such that ( b, a ) ∈ E and ∃ ψ ∈ pre n ( a ) , net ( b, ψ ) > 0 . However, even when a is applicable in s t , it maybe not  applicable at t if b is applied at t such that ( b, a ) ∈ E and ∃ ψ ∈ pre n ( a ) , net ( b, ψ ) < 0 .
Revised: Even when a is not applicable in s t , it may be applicable at t if b is applied at t such that ( b, a ) ∈ E and ∃ ψ ∈ pre n ( a ) , net ( b, ψ ) > 0 . However, even when a is applicable in s t , it may not be applicable at t if b is applied at t such that ( b, a ) ∈ E and ∃ ψ ∈ pre n ( a ) , net ( b, ψ ) < 0 .

Original: Therefore, Constraint (27) is modiﬁed as follows:
Revised: Therefore, Constraint (27) is modiﬁed as follows:

Original: [Equation]
Revised: [Equation]

Original: The left-hand side is now considering effects of b , and the big-M value in the right-hand side is modiﬁed accordingly.
Revised: The left-hand side is now considering effects of b , and the big-M value in the right-hand side is modiﬁed accordingly.

Original: Similarly, the linear effects of a at time step t must consider the change of values of ∀ v ∈ rhs l ( a ) within t caused by simple effects of actions b with ( b, a ) ∈ E .
Revised: Similarly, the linear effects of a at time step t must consider the change of values of ∀ v ∈ rhs l ( a ) within t caused by simple effects of actions b with ( b, a ) ∈ E .

Original: Constraints (30) and (31) are modiﬁed as follows:
Revised: Constraints (30) and (31) are modiﬁed as follows:

Original: [Equation]
Revised: [Equation]

Original: where big-M values are also modiﬁed as
Revised: where big-M values are also modiﬁed as

Original: [Equation]
Revised: [Equation]

Original: In addition, Equations (42) and (43) are modiﬁed as follows:a
Revised: In addition [Equation] Equations (42) and (43) are modiﬁed as follows:

Original: [Equation]
Revised: [Equation]

Original: Now we deﬁne the actual precedence relations.
Revised: Now we deﬁne the actual precedence relations.

Original: If b is applied before a and b has linear effects on the preconditions of a , whether a is applicable or not cannot be represented by Constraint (49) because the linear effects depend on the state in which b is applied.
Revised: If b is applied before a and b has linear effects on the preconditions of a , whether a is applicable or not cannot be represented by Constraint (49) because the linear effects depend on the state in which b is applied.

Original: Therefore, such a b must be applied after a .
Revised: Therefore, such a b must be applied after a .

Original: If a is applied before b and a has simple effects on variables in rhs l ( b ) ∪ lhs l ( b ) , the value of v ∈ lhs l ( b ) at t +1 is represented by y vt +1 in Constraints (50) and (51); if a changes variables in rhs l ( b ) , the change is considered in the constraints.
Revised: If a is applied before b and a has simple effects on variables in rhs l ( b ) ∪ lhs l ( b ) , the value of v ∈ lhs l ( b ) at t +1 is represented by y vt +1 in Constraints (50) and (51); if a changes variables in rhs l ( b ) , the change is considered in the constraints.

Original: If a changes v , the value of v is just overwritten by b .
Revised: If a changes v , the value of v is just overwritten by b .

Original: In contrast, if such an a is applied after b , y vt +1 may contradict the actual value of v at t +1 .
Revised: In contrast, if such an a is applied after b , y vt +1 may contradict the actual value of v at t +1 .

Original: Therefore, such an a must be applied before b .
Revised: Therefore, such an a must be applied before b .

Original: Based on the above observations, we ﬁrst deﬁne a subset of precedence relations E (cid:48) ⊆
Revised: Based on the above observations, we ﬁrst deﬁne a subset of precedence relations E (cid:48) ⊆

Original: E as follows:
Revised: E .

Original: [Equation]
Revised: [Equation]

Original: Suppose that ( a, b ) / ∈ E (cid:48) and ( b, a ) / ∈ E (cid:48) for a, b ∈ A .
Revised: Suppose that ( a, b ) / ∈ E (cid:48) and ( b, a ) / ∈ E (cid:48) for a, b ∈ A .

Original: When net ( b, ψ ) ≥ 0 for all ψ ∈ pre n ( a ) and s | = pre ( a ) , applying a after b is possible since s [[ b ]] always satisﬁes ∀ ψ ∈ pre n ( a ) .
Revised: When net ( b, ψ ) ≥ 0 for all ψ ∈ pre n ( a ) and s | = pre ( a ) , applying a after b is possible since s [[ b ]] always satisﬁes ∀ ψ ∈ pre n ( a ) .

Original: Conversely, when net ( b, ψ ) < 0 for some  ψ ∈ pre n ( a ) and s | = pre ( a ) , applying a after b is impossible if s [[ b ]] does not satisfy ψ .
Revised: Conversely, when net ( b, ψ ) < 0 for some [Table] ψ ∈ pre n ( a ) and s | = pre ( a ) , applying a after b is impossible if s [[ b ]] does not satisfy ψ .

Original: Therefore, when net ( b, ψ ) < 0 , we add edge ( a, b ) to E so that b is applied after a . 
Revised: Therefore, when net ( b, ψ ) < 0 , we add edge ( a, b ) to E so that b is applied after a . E [Equation] a

Original: [Equation]
Revised: [Equation]

Revised: a

Revised: [Equation]

Revised: A

Revised: [Equation]

Revised: pre n ( a ) , net ( b, ψ ) < 0 , (

Revised: [Equation]

Revised: [Equation]

Revised: (cid:48)

Revised: [Equation]

Original:  Now, Equation (33) is relaxed as follows:
Revised: [Equation] (cid:54) [Equation] Now, Equation (33) is relaxed as follows:

Original: [Equation]
Revised: [Equation]

Original: Preprocessing Action Precedence
Revised: Preprocessing Action Precedence

Original: In the branch-and-cut algorithm, each time a solution is found, the callback procedure to ﬁnd cycles in graph (cid:104) V, E (cid:105) is executed.
Revised: In the branch-and-cut algorithm, each time a solution is found, the callback procedure to ﬁnd cycles in graph (cid:104) V, E (cid:105) is executed.

Original: However, if the graph has no cycle, we can skip the callback procedure and just use a branch-and-bound algorithm.
Revised: However, if the graph has no cycle, we can skip the callback procedure and just use a branch-and-bound algorithm.

Original: We can check if the graph has no cycle using topological sorting.
Revised: We can check if the graph has cycles using topological sorting.

Original: Motivated by this, we adopt the following procedure before solving the task:
Revised: We adopt the following procedure before solving the task:

Original: ∀ ( a, b ) ∈ E , if ( b, a ) ∈ E , remove ( a, b ) and ( b, a ) from E and update mutex ( a ) to mutex ( a ) ∪ { b } and mutex ( b ) to mutex ( b ) ∪ { a } . 2.
Revised: ∀ ( a, b ) ∈ E , if ( b, a ) ∈ E , remove ( a, b ) and ( b, a ) from E and update interfering ( a ) to interfering ( a ) ∪ { b } and interfering ( b ) to interfering ( b ) ∪ { a } . 2.

Original: Execute topological sorting of (cid:104) V, E (cid:105) .
Revised: Execute topological sorting of (cid:104) V, E (cid:105) .

Original: If there is no cycle, disable the callback procedure.
Revised: If there is no cycle, disable the callback procedure.

Original: In this procedure, we remove cycles formed by only two actions to increase the chance that there is no cycle.
Revised: In this procedure, we remove cycles formed by only two actions to increase the chance that there is no cycle.

Original: Summary of the MILP Based Methods
Revised: Summary of the MILP Based Methods

Original: We denote the baseline MILP based method proposed by
Revised: We denote the baseline MILP based method proposed by

Original: Piacentini et al.
Revised: Piacentini et al.

Original: (2018a) by C SC and our MILP based method using the branch-and-cut algorithm by C SCcut .
Revised: (2018a) by C SC and our MILP based method using the branch-and-cut algorithm by C SCcut .

Original: The constraints used in the MILP based methods are summarized in Table 2.
Revised: The constraints used in the MILP based methods are summarized in Table 2.

Original: C SC

Original: C SCcut

Original: [Table]

Original: Experimental Evaluation Conﬁgurations of the MILP Based Methods
Revised: Experimental Evaluation Conﬁgurations of the MILP Based Methods

Original: Both methods use the iterative time horizon allocation method [Table] and the delete relaxation heuristic h C IP (Piacentini et al.
Revised: Both methods use the iterative time horizon allocation method, and the delete relaxation heuristic h C IP (Piacentini et al.

Original: 2018b) is used to compute a lower bound of the cost of an optimal plan.
Revised: 2018b) is used to compute a lower bound of the cost of an optimal plan.

Original: h C IP ignores numeric conditions in LT s since they only support SCT s. Since computing h C IP ( s I ) generates a relaxed plan, the length of the relaxed plan is used as the initial time horizon.
Revised: h C IP ignores numeric conditions in LT s since they only support SCT s. Since computing h C IP ( s I ) generates a relaxed plan, the length of the relaxed plan is used as the initial time horizon.

Original: These are the same settingsas those used in Piacentini et al.
Revised: These are the same settings used in Piacentini et al.

Original: (2018a).
Revised: (2018a).

Original: If the length of the relaxed plan is zero, we use T = 1 as the initial time horizon.
Revised: If the length of the relaxed plan is zero, we use T = 1 as the initial time horizon.

Original: In C SCcut , the callback procedure is executed at every node in the branchand-bound tree.
Revised: In C SCcut , the callback procedure is executed at every node in the branchand-bound tree.

Original: If one cycle is found at some time step, cycle elimination constraints are added for all time steps, and the callback procedure is terminated.
Revised: If one cycle is found at some time step, cycle elimination constraints are added for all time steps, and the callback procedure is terminated.

Original: Therefore, at most one cycle is found at each execution of the callback procedure.
Revised: Therefore, at most one cycle is found at each execution of the callback procedure.

Original: Experimental Settings
Revised: Experimental Settings

Original: We implemented the MILP based methods on top of Numeric Fast Downward (NFD) (Aldinger and Nebel 2017)using C++11 with GCC 7.5.0 and Gurobi 9.1.1 on Ubuntu 18.04.
Revised: We implemented the MILP based methods on top of Numeric Fast Downward (NFD) (Aldinger and Nebel 2017)using C++11 with GCC 7.5.0 and Gurobi 9.1.1 on Ubuntu 18.04.

Original: However, for the heuristics, we use CPLEX 12.
Revised: However, for the heuristics, we use CPLEX 12.

Original: since Gurobi is not supported by the implementations of the heuristics in NFD.
Revised: since Gurobi is not supported by the implementations of the heuristics in NFD.

Original: All experiments are run on an Intel(R)
Revised: All experiments are run on an Intel(R)

Original: Xeon(R) CPU E5-2620 @2.00GHz processor.
Revised: Xeon(R) CPU E5-2620 @2.00GHz processor.

Original: We use aminutes time limit and 4GB memory limit for each instance.
Revised: We use aminutes time limit and 4GB memory limit for each instance.

Original: Numeric planning domains in SCT s and LT s are taken from the literature (Scala, Haslum, and Thi´ebaux 2016;
Revised: Numeric planning domains in SCT s and LT s are taken from the literature (Scala, Haslum, and Thi ´ ebaux 2016;

Original: Scala et al.
Revised: Scala et al.

Original: 2017; 2020a; Li et al.
Revised: 2017, 2020a; Li et al.

Original: and IPC 3 removing duplicate instances.
Revised: and IPC 3 removing duplicate instances.

Original: The instances in SCT s are basically the same as those used by Kuroiwa et al.
Revised: The instances in SCT s are basically the same as those used by Kuroiwa et al.

Original: , but we use the unit cost versions of D EPOTS , R OVERS , and S ATELLITE since they have actions with the costs of zero.
Revised: , but we use the unit cost versions of D EPOTS , R OVERS , and S ATELLITE since they have actions with the costs of zero, which are not supported by the iterative time horizon allocation method.

Original: We also exclude F ARMLAND -SAT since NFD runs out of memory when preprocessing the PDDL ﬁles.
Revised: We also exclude F ARMLAND -SAT since NFD runs out of memory when preprocessing the PDDL ﬁles.

Original: Comparison of the MILP Based Methods
Revised: Comparison of the MILP Based Methods

Original: We show the comparison of the two MILP based methods in Table 3.
Revised: We show the comparison of the two MILP based methods in Table 3.

Original: ‘C’ is coverage, the number of solved instances within the limits, ‘Time’ is the time to ﬁnd the optimal plan, ‘I’ is the number of iterations used by the iterative time horizon allocation method, and ‘Constraints’ is the number of constraints in the model used in the last iteration.
Revised: ‘C’ is coverage, the number of solved instances within the limits, ‘Time’ is the time to ﬁnd the optimal plan, ‘I’ is the number of iterations used by the iterative time horizon allocation method, and ‘Constraints’ is the number of constraints in the model used in the last iteration.

Original: ‘Cycles’ is the number of eliminated cycles in (cid:104) V, E (cid:105) by the branch-and-cut algorithm, and ‘-’ indicates that there are no cycles in the domain.
Revised: ‘Cycles’ is the number of eliminated cycles in (cid:104) V, E (cid:105) by the branch-and-cut algorithm, and ‘-’ indicates that there are no cycles in the domain.

Original: In SCT s, only three domains have cycles in (cid:104) V, E (cid:105) .
Revised: In SCT s, only three domains have cycles in (cid:104) V, E (cid:105) .

Original: In LT s, there are no cycles at all.
Revised: In LT s, there are no cycles at all.

Original: C sccut has fewer constraints than C sc in the majority of domains.
Revised: C sccut has fewer constraints than C sc in the majority of domains.

Original: In 7 domains, C sccut reduces the number of iterations compared to C sc , which means that C sccut ﬁnds a feasible solution with fewer time steps.
Revised: In 7 domains, C sccut reduces the number of iterations compared to C sc , which means that C sccut ﬁnds a feasible solution with fewer time steps.

Original: Among these domains, C sccut achieves speed up in G ARDENING -SAT, FO-C OUNTERS -I NV , and
Revised: Among these domains, C sccut achieves speed up in G ARDENING -SAT, FO-C OUNTERS -I NV , and

Original: FO-C OUNTERS -R ND and solves two more instance in FOC OUNTERS -R ND .
Revised: FO-C OUNTERS -R ND and solves two more instance in FOC OUNTERS -R ND .

Original: Comparison with Other Approaches
Revised: Comparison with Other Approaches

Original: Next, we compare the MILP based methods with other approaches.
Revised: Next, we compare the MILP based methods with other approaches.

Original: In SCT s, we evaluate A* search (Hart, Nilsson,and Raphael 1968) with h C IP and h LM-cut ,SEQ LP , the operatorcounting heuristic with the LM-cut and state-equation constraints (Kuroiwa et al. 2021).
Revised: In SCT s, we evaluate A* search (Hart, Nilsson, C SC [Table] SCcut

Revised: [Table]

Revised: Constraints

Revised: [Table]

Original:  These are the state-of-the-art admissible heuristics in SCT s. In LT s, we evaluate A* search with the blind heuristic which returns zero if a state is a goal state and min a ∈A cost ( a ) otherwise, h C IP ignoring numeric conditions, the interval-based max heuristic ( h iimax ) (Aldinger and Nebel 2017), and the repetition-based max heuristic ( h irmax )
Revised: [Table] [Table] and Raphael 1968) with h C IP and h LM-cut ,SEQ LP , the operatorcounting heuristic with the LM-cut and state-equation constraints (Kuroiwa et al. 2021). These are the state-of-the-art admissible heuristics in SCT s. In LT s, we evaluate A* search with the blind heuristic which returns zero if a state is a goal state and min a ∈A cost ( a ) otherwise, h C IP ignoring nu- meric conditions, the interval-based max heuristic ( h iimax ) (Aldinger and Nebel 2017), and the repetition-based max heuristic ( h irmax )

Original: (Aldinger and Nebel 2017).
Revised: (Aldinger and Nebel 2017).

Original: To our knowledge, these are the only existing admissible heuristics in LT s.
Revised: To our knowledge, these are the only existing admissible heuristics in LT s.

Original: In addition, we evaluate OMTPlan (Leofante et al. 2020), a planner for optimal numeric planning based on optimization modulo theories in LT s. The results in SCT s and LT s are shown in Table 4 and 5, respectively.
Revised: In addition, we evaluate OMTPlan (Leofante et al. 2020), a planner for optimal numeric planning based on optimization modulo theories in LT s. The results in SCT s and LT s are shown in Table 4 and 5, respectively.

Original: In both classes of numeric planning tasks, the heuristic search algorithms clearly outperform the MILP based methods.
Revised: In both classes of numeric planning tasks, the heuristic search algorithms clearly outperform the MILP based methods.

Original: In LT s, OMTPlan solves more instances than the MILP based methods in domains other than FO-F ARMLAND .
Revised: In LT s, OMTPlan solves more instances than the MILP based methods in domains other than FO-F ARMLAND .

Original: Conclusion
Revised: Conclusion

Original: In this paper, we propose a novel MILP compilation of numeric planning using a branch-and-cut algorithm.
Revised: In this paper, we propose a novel MILP compilation of numeric planning using a branch-and-cut algorithm.

Original: In the experimental evaluation, the new MILP based method ﬁnd the optimal solution faster than the existing MILP based method in some domains and solves more instances in one domain of linear numeric planning tasks.
Revised: In the experimental evaluation, the new MILP based method ﬁnds the optimal solution faster than the existing MILP based method in some domains and solves more instances in one domain of linear numeric planning tasks.

Original: However, the number of solved instances is not increased in any domain of numeric planning tasks with simple conditions.
Revised: However, the number of solved instances is not increased in any domain of numeric planning tasks with simple conditions.

Original: Compared with other approaches, the MILP based methods do not solve more instances than A* with admissible heuristics in any domain.
Revised: Compared with other approaches, the MILP based methods do not solve more instances than A* with admissible heuristics in any domain.

Original: Developing more competitive MILP compilations is future work.
Revised: Developing more competitive MILP compilations is future work.

Original: Nevertheless, the performance may be improved without effort in future since the MILP based methods can C SC [Table] SCcut
Revised: Nevertheless, the performance may be improved without effort in future since the MILP based methods can beneﬁt from the progress on the off-the-shelf solvers.

Original: [Table]

Original: Constraints

Original: [Table]

Original: [Table] [Table] beneﬁt from the progress on the off-the-shelf solvers. In addition, better admissible heuristics will improve the performance of the iterative time horizon allocation method used in the MILP based methods by providing stronger lower bounds of the time horizon.
Revised: In addition, better admissible heuristics will improve the performance of the iterative time horizon allocation method used in the MILP based methods by providing stronger lower bounds of the time horizon.

Original: Pursuing better MILP compilations of planning tasks has an important meaning to the planning community even if they are not competitive with other approaches for now.
Revised: Pursuing better MILP compilations of planning tasks has an important meaning to the planning community even if they are not competitive with other approaches for now.