Original: Branch & Learn for Recursively and Iteratively Solvable Problems in Predict+Optimize
Revised: Branch & Learn for Recursively and Iteratively Solvable Problems in Predict+Optimize

Original: Abstract
Revised: Abstract

Original: This paper proposes Branch & Learn , a framework for Predict+Optimize to tackle optimization problems containing parameters that are unknown at the time of solving.
Revised: This paper proposes Branch & Learn , a framework for Predict+Optimize to tackle optimization problems containing parameters that are unknown at the time of solving.

Original: Given an optimization problem solvable by a recursive algorithm satisfying simple conditions, we generalize previous work substantially by showing how a corresponding learning algorithm can be constructed directly and methodically from the recursive algorithm.
Revised: Given an optimization problem solvable by a recursive algorithm satisfying simple conditions, we generalize previous work substantially by showing how a corresponding learning algorithm can be constructed directly and methodically from the recursive algorithm.

Original: Our framework applies also to iterative algorithms by viewing them as a degenerate form of recursion.
Revised: Our framework applies also to iterative algorithms by viewing them as a degenerate form of recursion.

Original: Extensive experimentation shows better performance for our proposal over classical and state of the art approaches.
Revised: Extensive experimentation shows better performance for our proposal over classical and state of the art approaches.

Original:  Introduction
Revised:  Introduction

Original: In the intersection of machine learning and constrained optimization, the Predict+Optimize framework tackles optimization problems with parameters that are unknown at solving time.
Revised: In the intersection of machine learning and constrained optimization, the Predict+Optimize framework tackles optimization problems with parameters that are unknown at solving time.

Original: Such uncertainty is common in daily life and industry.
Revised: Such uncertainty is common in daily life and industry.

Original: For example, retailers need to pick items to restock for maximizing proﬁt, yet consumer demand is a-priori unknown.
Revised: For example, retailers need to pick items to restock for maximizing profit, yet consumer demand is a-priori unknown.

Original: The task is to i) predict the unknown parameters, then ii) solve the optimization problem using the predicted parameters, such that the resulting solutions are good even under true parameters.
Revised: The task is to i) predict the unknown parameters, then ii) solve the optimization problem using the predicted parameters, such that the resulting solutions are good even under true parameters.

Original: Traditionally, the parameter prediction uses standard machine learning techniques, with error measures independent of the optimization problem.
Revised: Traditionally, the parameter prediction uses standard machine learning techniques, with error measures independent of the optimization problem.

Original: Thus, the predicted parameters may in fact lead to a lowquality solution for the (true) optimization problem despite being “high-quality" for the error metric.
Revised: Thus, the predicted parameters may in fact lead to a lowquality solution for the (true) optimization problem despite being “high-quality" for the error metric.

Original: The Predict+Optimize framework uses the more effective regret function [3, 6, 9] as the error metric, capturing the difference in objective (computed under the true parameters) between the estimated and true optimal solutions.
Revised: The Predict+Optimize framework uses the more effective regret function [3, 6, 9] as the error metric, capturing the difference in objective (computed under the true parameters) between the estimated and true optimal solutions.

Original: However, the regret function is usually not (sub-)differentiable, and gradient-based methods do not apply.
Revised: However, the regret function is usually not (sub-)differentiable, and gradient-based methods do not apply.

Original: Prior works have focused on the regime where the optimization problems contain unknown objective and known constraints, and proposed ways to overcome the non-differentiability of the regret.
Revised: Prior works have focused on the regime where the optimization problems contain unknown objective and known constraints, and proposed ways to overcome the non-differentiability of the regret.

Original: They can be roughly divided into two approaches: approximation and exact .
Revised: They can be roughly divided into two approaches: approximation and exact .

Original: The former tries to compute the (approximate) gradients of (approximations of) the regret function.
Revised: The former tries to compute the (approximate) gradients of (approximations of) the regret function.

Original: Elmachtoub et al.
Revised: Elmachtoub et al.

Original: [6] propose a differentiable surrogate function for the regret function, while Wilder et al.
Revised: [6] propose a differentiable surrogate function for the regret function, while Wilder et al.

Original: [17] relax the integral objective in constrained optimization and solve a regularized quadratic programming problem.
Revised: [17] relax the integral objective in constrained optimization and solve a regularized quadratic programming problem.

Original: Mandy and Guns [12] focus on mixed integer linear programs and propose an interior point based approach.
Revised: Mandy and Guns [12] focus on mixed integer linear programs and propose an interior point based approach.

Original: While novel, approximation approaches are not always reliable.
Revised: While novel, approximation approaches are not always reliable.

Original: Exact approaches exploit the structure of optimization problems to train models without computing gradients.
Revised: Exact approaches exploit the structure of optimization problems to train models without computing gradients.

Original: Demirovi´c et al.
Revised: Demirovi´c et al.

Original: [4] investigate problems with the ranking property and propose a large neighborhood search method to learn a linear prediction function.
Revised: [4] investigate problems with the ranking property and propose a large neighborhood search method to learn a linear prediction function.

Original: They [5] further extend the method to enable Predict+Optimize for problems amenable to tabular dynamic programming (DP).
Revised: They [5] further extend the method to enable Predict+Optimize for problems amenable to tabular dynamic programming (DP).

Revised: 36th Conference on Neural Information Processing Systems (NeurIPS 2022).

Original: We propose a novel exact method for problems solvable with a recursive algorithm (under some restrictions), signiﬁcantly generalizing the work of Demirovi´c et al.
Revised: We propose a novel exact method for problems solvable with a recursive algorithm (under some restrictions), significantly generalizing the work of Demirovi´c et al.

Original: By viewing iteration as a special case of recursion with a single branch, our framework applies also to iterative algorithms.
Revised: By viewing iteration as a special case of recursion with a single branch, our framework applies also to iterative algorithms.

Original: Recall that DP is a special case of recursion, where the recursion structure has overlapping subproblems, enabling the use of memoization to avoid recomputation.
Revised: Recall that DP is a special case of recursion, where the recursion structure has overlapping subproblems, enabling the use of memoization to avoid recomputation.

Original: In particular, tabular DP is implemented as an iterative algorithm, computing the table row by row.
Revised: In particular, tabular DP is implemented as an iterative algorithm, computing the table row by row.

Original: While tabular DP is a widely applicable technique, it is not universal in that many naturally recursively solvable problems are not known to have a DP algorithm.
Revised: While tabular DP is a widely applicable technique, it is not universal in that many naturally recursively solvable problems are not known to have a DP algorithm.

Original: For example, many modern combinatorial search algorithms are still fundamentally based on exhaustive search.
Revised: For example, many modern combinatorial search algorithms are still fundamentally based on exhaustive search.

Original: Our work thus subsumes the method by Demirovi´c et al.
Revised: Our work thus subsumes the method by Demirovi´c et al.

Original: [5] and extends the Predict+Optimize framework to a much wider class of optimization problems.
Revised: [5] and extends the Predict+Optimize framework to a much wider class of optimization problems.

Original: Experiments on 3 benchmarks with artiﬁcial and real-life data against 9 other learning approaches conﬁrm the superior solution quality and scalability of our method.
Revised: Experiments on 3 benchmarks with artificial and real-life data against 9 other learning approaches confirm the superior solution quality and scalability of our method.

Original: The concurrent work by Guler et al.
Revised: The concurrent work by Guler et al.

Original: [9], just accepted to AAAI22, proposes a divide and conquer algorithm, extending the work of Demirovi´c et al.
Revised: [9], just accepted to AAAI22, proposes a divide and conquer algorithm, extending the work of Demirovi´c et al.

Original: [5] by considering optimization problems whose objective function is a bilinear function in the decision variables and the unknown parameters.
Revised: [5] by considering optimization problems whose objective function is a bilinear function in the decision variables and the unknown parameters.

Original: While both Branch & Learn and [9] are exact methods for Predict+Optimize, there are problems amenable to Branch & Learn but not [9], and vice versa.
Revised: While both Branch & Learn and [9] are exact methods for Predict+Optimize, there are problems amenable to Branch & Learn but not [9], and vice versa.

Original: The techniques used are also very different between the two works.
Revised: The techniques used are also very different between the two works.

Original: Section 6 compares the two pieces of work in more detail.
Revised: Section 6 compares the two pieces of work in more detail.

Original:  Background
Revised:  Background

Original: Without loss of generality, an optimization problem is to ﬁnd x ⇤ =
Revised: Without loss of generality, an optimization problem is to find x ∗ =

Original: arg min x obj ( x ) s.t. C ( x ) , where x 2 R d is a vector of decision variables,
Revised: arg min x obj ( x ) s.t. C ( x ) , where x ∈ R d is a vector of decision variables,

Original: obj : R d ! R is a function mapping x to an objective value to be minimized, and C is a set of constraints over x .
Revised: obj : R d → R is a function mapping x to an objective value to be minimized, and C is a set of constraints over x .

Original: Thus, x ⇤ is an optimal solution and obj ( x ⇤ ) is the optimal value .
Revised: Thus, x ∗ is an optimal solution and obj ( x ∗ ) is the optimal value .

Original: In this (and prior) work, we focus on cases where only the objective contains uncertainty.
Revised: In this (and prior) work, we focus on cases where only the objective contains uncertainty.

Original: A parameterized optimization problem (Para-OP) P ( ✓ ) thus extends the problem P as:
Revised: A parameterized optimization problem (Para-OP) P ( θ ) thus extends the problem P as:

Original: [Equation]
Revised: [Equation]

Original: where ✓ 2 R t is a vector of parameters.
Revised: where θ ∈ R t is a vector of parameters.

Original: The objective now depends also on ✓ .
Revised: The objective now depends also on θ .

Original: When the parameters are known, a Para-OP is just an optimization problem.
Revised: When the parameters are known, a Para-OP is just an optimization problem.

Original: Example 1.
Revised: Example 1.

Original: Consider a project funding problem to maximize P [Equation] i subject to the budget constraint 2 x 1 + 2 x 2 + x 3 + x 3 , where p is an array representing the proﬁts of projects.
Revised: Consider a project funding problem to maximize (cid:80) 4 i =1 p i · x i subject to the budget constraint 2 x 1 + 2 x 2 + x 3 + x 4 ≤ 3 , where p is an array representing the profits of projects.

Original: The problem is an instance of 0-1 knapsack.
Revised: The problem is an instance of 0-1 knapsack.

Original: However, p is usually unknown at decision time, with only some features related to it given, such as proposal scores and the reputation of each applicant.
Revised: However, p is usually unknown at decision time, with only some features related to it given, such as proposal scores and the reputation of each applicant.

Original: In Predict+Optimize [5], the true parameters ✓ 2 R t for a Para-OP are unknown at solving time, and estimated parameters ˆ ✓ are used instead.
Revised: In Predict+Optimize [5], the true parameters θ ∈ R t for a Para-OP are unknown at solving time, and estimated parameters ˆ θ are used instead.

Original: Suppose each parameter is estimated by m features.
Revised: Suppose each parameter is estimated by m features.

Original: The estimation will rely on a machine learning model trained over n observations of a training data set { ( A 1 , ✓ 1 ) , . . .
Revised: The estimation will rely on a machine learning model trained over n observations of a training data set { ( A 1 , θ 1 ) , . . .

Original: , ( A n , ✓ n ) } , where A i 2 R t ⇥ m is a feature matrix for ✓ i , so as to yield a prediction function f : R t ⇥ m ! R t for estimating parameters ˆ ✓ = f ( A ) .
Revised: , ( A n , θ n ) } , where A i ∈ R t × m is a feature matrix for θ i , so as to yield a prediction function f : R t × m → R t for estimating parameters ˆ θ = f ( A ) .

Original: The quality of the estimated parameters ˆ ✓ is measured by the regret function , which is the objective difference between the true optimal solution x ⇤ ( ✓ ) and the estimated optimal solution x ⇤ (ˆ ✓ ) under the true parameters ✓ .
Revised: The quality of the estimated parameters ˆ θ is measured by the regret function , which is the objective difference between the true optimal solution x ∗ ( θ ) and the estimated optimal solution x ∗ (ˆ θ ) under the true parameters θ .

Original: Formally, we deﬁne the regret function Regret (ˆ ✓ , ✓ ) :R t ⇥ R t !
Revised: Formally, we define the regret function Regret (ˆ θ, θ ) :

Original: R  0 to be:
Revised: R t × R t → R ≥ 0 to be:

Original: [Equation]
Revised: [Equation]

Original: where obj ( x ⇤ (ˆ ✓ ) , ✓ ) is the estimated optimal value and obj ( x ⇤ ( ✓ ) , ✓ ) is the true optimal value .
Revised: where obj ( x ∗ (ˆ θ ) , θ ) is the estimated optimal value and obj ( x ∗ ( θ ) , θ ) is the true optimal value .

Original: Following the empirical risk minimization principle, Elmachtoub et al.
Revised: Following the empirical risk minimization principle, Elmachtoub et al.

Original: [7] choose the prediction function from the set of models F to attain the smallest average regret over the training data:
Revised: [7] choose the prediction function from the set of models F to attain the smallest average regret over the training data:

Original: [Equation]
Revised: [Equation]

Original: For discrete optimization problems, the regret is not (sub) differentiable.
Revised: For discrete optimization problems, the regret is not (sub) differentiable.

Original: Hence, traditional (sub- )gradient-based training algorithms are not applicable.
Revised: Hence, traditional (sub- )gradient-based training algorithms are not applicable.

Original: Demirovi´c et al.
Revised: Demirovi ´ c et al.

Original: [5] study the class F of linear prediction functions and propose to represent the solution structure of a Para-OP using (continuous) piecewise linear functions.
Revised: [5] study the class F of linear prediction functions and propose to represent the solution structure of a Para-OP using (continuous) piecewise linear functions.

Original: A piecewise linear function h is a real-valued function deﬁned on a ﬁnite set of (closed) intervals I ( h ) partitioning R .
Revised: A piecewise linear function h is a real-valued function defined on a finite set of (closed) intervals I ( h ) partitioning R .

Original: Each interval I 2 I ( h ) is associated with a linear function h
Revised: Each interval I ∈ I ( h ) is associated with a linear function h

Original: [ I ] of the form h
Revised: [ I ] of the form h

Original: [ I ]( r ) =
Revised: [ I ]( r ) =

Original: a I r + b I , and the value of h ( r ) for a real number r 2 R is given by h
Revised: a I r + b I , and the value of h ( r ) for a real number r ∈ R is given by h

Original: [ I ]( r ) where r 2 I .
Revised: [ I ]( r ) where r ∈ I .

Original: An algebra can be canonically deﬁned on piecewise linear functions [15].
Revised: An algebra can be canonically defined on piecewise linear functions [15].

Original: For piecewise linear functions h and g , we deﬁne pointwise addition as ( h + g )( r )
Revised: For piecewise linear functions h and g , we define pointwise addition as ( h + g )( r )

Original: = h ( r ) + g ( r ) for all r 2 R .
Revised: = h ( r ) + g ( r ) for all r ∈ R .

Original: Pointwise subtraction, max/min and scalar products are similarly deﬁned.
Revised: Pointwise subtraction, max/min and scalar products are similarly defined.

Original: All ﬁve operations can be computed efﬁciently by iterating over intervals of the operands [5]
Revised: All five operations can be computed efficiently by iterating over intervals of the operands [5].

Original: In the rest of the paper, we assume that the prediction function f is a linear mapping of the form f ( A ) =
Revised: In the rest of the paper, we assume that the prediction function f is a linear mapping of the form f ( A ) =

Original: A ↵ for some m -dimensional vector of coefﬁcients ↵ 2 R m .
Revised: Aα for some m -dimensional vector of coefficients α ∈ R m .

Original: To (approximately) solve problem (1), Demirovi´c et al.
Revised: To (approximately) solve problem (1), Demirovi´c et al.

Original: [5] proposes to update the coefﬁcients ↵ of f iteratively via coordinate descent (Algorithm 1), in which ↵ are initialized arbitrarily and updated in a round-robin fashion.
Revised: [5] proposes to update the coefficients α of f iteratively via coordinate descent (Algorithm 1), in which α are initialized arbitrarily and updated in a round-robin fashion.

Original: Each iteration (lines 3-10) contains three functions.
Revised: Each iteration (lines 3-10) contains three functions.

Original: Construct constructs a
Revised: Construct constructs a

Original: Para-OP as a function of the free coefﬁcient , ﬁxing the other coefﬁcients in ↵ , with an initial domain
Revised: Para-OP as a function of the free coefficient , fixing the other coefficients in α , with an initial domain

Original: I 0 .
Revised: I 0 .

Original: Convert returns a piecewise linear function of the free coefﬁcient from the Para-OP, and each interval of the function corresponds to an estimated optimal solution.
Revised: Convert returns a piecewise linear function of the free coefficient from the Para-OP, and each interval of the function corresponds to an estimated optimal solution.

Original: Evaluate takes the returned function and the true parameters as inputs, computes the estimated optimal value, and obtains the regret as a piecewise constant function of the free coefﬁcient.
Revised: Evaluate takes the returned function and the true parameters as inputs, computes the estimated optimal value, and obtains the regret as a piecewise constant function of the free coefficient.

Original: As Algorithm 1 shows, in each iteration (lines 3-10), an coefﬁcient ↵ k is updated.
Revised: As Algorithm 1 shows, in each iteration (lines 3-10), an coefficient α k is updated.

Original: Iterating over index k 2 { 1 , . .
Revised: Iterating over index k ∈ { 1 , . .

Original: . , m } , we replace ↵ k in ↵ with a variable  2 R by constructing ↵ + (   ↵ k ) e k , where e k is a unit vector for coordinate k .
Revised: . , m } , we replace α k in α with a variable γ ∈ R by constructing α + ( γ − α k ) e k , where e k is a unit vector for coordinate k .

Original: In lines 5-10, we wish to update ↵ k as:
Revised: In lines 5-10, we wish to update α k as:

Original: [Equation]
Revised: [Equation]

Original: Let us describe lines 6-8 in more detail.
Revised: Let us describe lines 6-8 in more detail.

Original: For notational convenience, let a i
Revised: For notational convenience, let a i

Original: =
Revised: =

Original: A i e k 2 R m and b i =
Revised: A i e k ∈ R m and b i =

Original: A i ( ↵  ↵ k e k ) 2 R m , which are vectors independent of the free variable  .
Revised: A i ( α − α k e k ) ∈ R m , which are vectors independent of the free variable γ .

Original: Construct synthesizes the parameterized problem
Revised: Construct synthesizes the parameterized problem

Original: [Equation]
Revised: [Equation]

Original: Sometimes, the parameterized problem can also have an initial domain I 0 [-
-] =
Revised: Sometimes, the parameterized problem can also have an initial domain I 0 [-
-]̸ =

Original: R for  .
Revised: R for γ .

Original: For instance, we may restrict the estimated proﬁts to be non-negative in Example 1.
Revised: For instance, we may restrict the estimated profits to be non-negative in Example 1.

Original: Convert takes P i  to create a function E i mapping  to the estimated objective E i (  ) =
Revised: Convert takes P iγ to create a function E i mapping γ to the estimated objective E i ( γ ) =

Original: obj ( x ⇤ ( a i  + b i ) , a i  + b i ) .
Revised: obj ( x ∗ ( a i γ + b i ) , a i γ + b i ) .

Original: Associated with each interval I 2 I ( E i (  )) , a linear function maps  to the objective computed with the estimated parameters a i  + b i , and the estimated optimal solution x ⇤ ( a i  + b i ) remains the same in each interval I [4, 5].
Revised: Associated with each interval I ∈ I ( E i ( γ )) , a linear function maps γ to the objective computed with the estimated parameters a i γ + b i , and the estimated optimal solution x ∗ ( a i γ + b i ) remains the same in each interval I [4, 5].

Original: From this, Evaluate computes the regret L i for each interval I , i.e.
Revised: From this, Evaluate computes the regret L i for each interval I , i.e.

Original: L i [ I ] =
Revised: L [Equation]

Original: Regret ( a i  ( I ) + b i , ✓ i ) =
Revised: [Equation]

Original: obj ( x ⇤ ( a i  ( I ) + b i ) , ✓ i )  obj ( x ⇤ ( ✓ i ) , ✓ i ) BaseCase
Revised: [Equation]

Original: ; else T
Revised: θ i [Equation]

Original: PL
Revised: obj

Original: C
Revised: [Equation] i [Equation]

Original: Reduce (
Revised: [Equation]

Original: ; return
Revised: b i [Equation] i [Equation]

Original: ; 10 Function ReLearn ( P  , I
Revised: 1 Function ReSolve ( P, θ ) :

Original: : if isBaseCase ( P I 0 ) 
Revised: if isBaseCase ( P ) then ( x ∗ ( θ ) , C ∗ ( θ )) ← BaseCase ( P, θ ) ; else

Original:  then
Revised: T ← Extract ( P, θ ) ; PL ← Branch ( P, θ, T ) ; RL ← Map ( ReSolve , PL ) ; ( x ∗ ( θ ) , C ∗ ( θ )) ← Reduce ( ⊕ , RL ) ; return R ; 10 Function ReLearn ( P γ , I 0 ) : if isBaseCase ( P γ , I 0 ) then

Original: R  I 0 ]  BaseCaseL ( P  ; else
Revised: R [ I 0 ] ← BaseCaseL ( P γ ) ; else

Original: T  ExtractL ( P  , I  ; for each interval I 2 I 
Revised: T γ ← ExtractL ( P γ , I 0 ) ; for each interval I ∈ I ( T γ )

Original: ) do
Revised: do

Original: PL  BranchL( P
Revised: PL ← BranchL

Original:  , T 
Revised: ( P γ , T γ [ I ]) ;

Original: RL  Map  ReLearn 
Revised: RL ← Map ( ReLearn , PL ) ;

Original: R  Reduce (  ; return R ; where  is a function arbitrarily selecting a value from an interval I .
Revised: R [ I ] ← Reduce ( ⊞ , RL ) ; return R ; where χ is a function arbitrarily selecting a value from an interval I .

Original: The resulting function L i is piecewise constant and represents the regret for different values of the free coefﬁcient.
Revised: The resulting function L i is piecewise constant and represents the regret for different values of the free coefficient.

Original: If  / 2 I 0 , the value of L i is set to a sufﬁciently large constant to indicate impracticability of the estimation ˆ ✓ = a i  + b i .
Revised: If γ / ∈ I 0 , the value of L i is set to a sufficiently large constant to indicate impracticability of the estimation ˆ θ = a i γ + b i .

Original: Line 9 sums all L i (  ) into a piecewise constant total regret L (  ) across all training examples, and line 10 minimizes L (  ) by simply iterating over each interval of L (  ) .
Revised: Line 9 sums all L i ( γ ) into a piecewise constant total regret L ( γ ) across all training examples, and line 10 minimizes L ( γ ) by simply iterating over each interval of L ( γ ) .

Original: While coordinate descent is a standard technique, the key contribution by Demirovi´c et al.
Revised: While coordinate descent is a standard technique, the key contribution by Demirovi ´ c et al.

Original: [5] is to show how to build the Convert function for a tabular DP algorithm, by computing a modiﬁed
Revised: [5] is to show how to build the Convert function for a tabular DP algorithm, by computing a modified

Original: DP table with essentially the same structure.
Revised: DP table with essentially the same structure.

Original: In this paper, we signiﬁcantly generalize the method by constructing Convert for recursive and iterative algorithms, opening the Predict+Optimize framework to a much wider class of problems than just those solvable using DP algorithms.
Revised: In this paper, we significantly generalize the method by constructing Convert for recursive and iterative algorithms, opening the Predict+Optimize framework to a much wider class of problems than just those solvable using DP algorithms.

Original: A major obstacle to the generalization is that different prediction coefﬁcients  can lead to wildly different executions of the recursion, all of which need to be explored in order to optimize for  minimizing the empirical regret.
Revised: A major obstacle to the generalization is that different prediction coefficients γ can lead to wildly different executions of the recursion, all of which need to be explored in order to optimize for γ minimizing the empirical regret.

Original: At a high level, we overcome this challenge by presenting a standard template for recursive algorithms ( ReSolve in Algorithm 2), which we show can be cleanly adapted ( ReLearn ) to algorithmically enumerate all the possible recursion executions based on the free coefﬁcient  .
Revised: At a high level, we overcome this challenge by presenting a standard template for recursive algorithms ( ReSolve in Algorithm 2), which we show can be cleanly adapted ( ReLearn ) to algorithmically enumerate all the possible recursion executions based on the free coefficient γ .

Original:  Recursively Solvable Problems
Revised:  Recursively Solvable Problems

Original: This section describes the general form ( ReSolve in Algorithm 2) of recursive algorithms considered, which in particular captures also all DP algorithms without memoization applied.
Revised: This section describes the general form ( ReSolve in Algorithm 2) of recursive algorithms considered, which in particular captures also all DP algorithms without memoization applied.

Original: This template uses the following two higher-order functions:
Revised: This template uses the following two higher-order functions:

Original: Deﬁnition 1 (Map) .
Revised: Definition 1 (Map) .

Original: Suppose D, S are two sets and f : D ! S is a function.
Revised: Suppose D, S are two sets and f : D → S is a function.

Original: Map ( f, [ d 1 , . . .
Revised: Map ( f, [ d 1 , . . .

Original: , d l ]) returns a list [ f ( d 1 ) , . . .
Revised: , d l ]) returns a list [ f ( d 1 ) , . . .

Original: , f ( d l )] where d 1 , . .
Revised: , f ( d l )] where d 1 , . .

Original: , d l 2 D and f ( d i ) 2 S .
Revised: , d l ∈ D and f ( d i ) ∈ S .

Original: Deﬁnition 2 (Reduce) .
Revised: Definition 2 (Reduce) .

Original: Suppose S is a set and  : S ⇥ S ! S is a commutative and associative operation.
Revised: Suppose S is a set and ⊕ : S × S → S is a commutative and associative operation.

Original: Reduce (  , [ s 1 , s 2 , . . 
Revised: Reduce ( ⊕ , [ s 1 , s 2 , . . .

Original: , s l ]) returns s 1  s 2  · · ·  s l .
Revised: , s l ]) returns s 1 ⊕ s 2 ⊕ · · · ⊕ s l .

Original: The ReSolve function takes a recursively solvable Para-OP P and known parameters ✓ , and returns the optimal value and decisions C ⇤ and x ⇤ for P ( ✓ ) .
Revised: The ReSolve function takes a recursively solvable Para-OP P and known parameters θ , and returns the optimal value and decisions C ∗ and x ∗ for P ( θ ) .

Original: It has several key components: i) isBaseCase checks if P ( ✓ ) is a base case, and if so, BaseCase returns the result of P ( ✓ ) .
Revised: It has several key components: i) isBaseCase checks if P ( θ ) is a base case, and if so, BaseCase returns the result of P ( θ ) .

Original: ii) Extract , using the current problem P and current parameters ✓ , computes some information T which will determine the list of subproblems.
Revised: ii) Extract , using the current problem P and current parameters θ , computes some information T which will determine the list of subproblems.

Original: iii) Branch , using only T , creates and returns a list PL of subproblems, and computes the corresponding parameters from both T and the current parameters ✓ .
Revised: iii) Branch , using only T , creates and returns a list PL of subproblems, and computes the corresponding parameters from both T and the current parameters θ .

Original: iv)
Revised: iv)

Original: Each subproblem in PL is solved recursively, via Map mapping ReSolve to PL .
Revised: Each subproblem in PL is solved recursively, via Map mapping ReSolve to PL .

Original: After the recursive calls, the partial results in RL are aggregated by a binary operation  via Reduce .
Revised: After the recursive calls, the partial results in RL are aggregated by a binary operation ⊕ via Reduce .

Original: As mentioned, the ReSolve template also captures iterative algorithms as recursion with a single branch.
Revised: As mentioned, the ReSolve template also captures iterative algorithms as recursion with a single branch.

Original: We also restrict attention to algorithms satisfying: i) the only arithmetic operations involving the unknown parameters are + ,  , max , min and multiplication with known constants, ii) there are no conditionals within Branch , and iii) isBaseCase is independent of the parameters ✓ .
Revised: We also restrict attention to algorithms satisfying: i) the only arithmetic operations involving the unknown parameters are + , − , max , min and multiplication with known constants, ii) there are no conditionals within Branch , and iii) isBaseCase is independent of the parameters θ .

Original: Example 2.
Revised: Example 2.

Original: ReSolve_KS in Algorithm 3 is an instantiation of ReSolve for solving the project funding (0-1 knapsack) problem in Example 1.
Revised: ReSolve_KS in Algorithm 3 is an instantiation of ReSolve for solving the project funding (0-1 knapsack) problem in Example 1.

Original: ReSolve_KS takes input ( p, c, n, W, S ) where n is the number of remaining projects to consider, W is the available funding, and S are the selected projects so far.
Revised: ReSolve_KS takes input ( p, c, n, W, S ) where n is the number of remaining projects to consider, W is the available funding, and S are the 1 Function ReSolve_KS ( p, c, n, W, S ) : if n = 0 or W ≤ 0 then R ← 1 ( W ≥ 0) · (cid:80) i ∈ S p

Revised: [ i ] ; else [ P 1 , P 2 ] ← Branch_KS ( p, c, n, W, S ) ;

Revised: RL ← Map ( Resolve_KS , PL ) ;

Original: Initially, S =  ;.
Revised: R ← Reduce (max , RL ) ; return R ; 9 Function ReLearn_KS ( p γ , c, n, W, S, I ) : if n = 0 or W ≤ 0 then R [ I ] ← (cid:80) i ∈ S p γ [ i ] ; else [ P 1 , P 2 ] ← BranchL_KS ( p γ , c, n, W, S ) ; RL ← Map ( ReLearn_KS , PL ) ;

Revised: R [ I ] ← Reduce (max , RL ) ; return R [ I ] ; selected projects so far.

Revised: Initially, S = ∅ .

Original: Extract_KS is a no-op.
Revised: Extract_KS is a no-op.

Original: Branch_KS returns [( p, c, n  1 , W, S ) , ( p, c, n  1 , W  c [ n ] , S [ { n } )] , the two subproblems for whether the n th project is selected or not.
Revised: Branch_KS returns [( p, c, n − 1 , W, S ) , ( p, c, n − 1 , W − c [ n ] , S ∪{ n } )] , the two subproblems for whether the n th project is selected or not.

Original: isBaseCase checks if the total cost exceeds the budget or if no projects are left to consider.
Revised: isBaseCase checks if the total cost exceeds the budget or if no projects are left to consider.

Original: Limitations of requirements on the recursive algorithm Before Example 2, we speciﬁed re- quirements on recursive algorithms considered in this paper.
Revised: Limitations of requirements on the recursive algorithm Before Example 2, we specified requirements on recursive algorithms considered in this paper.

Original: Even though the framework is general, there are algorithms that the framework excludes.
Revised: Even though the framework is general, there are algorithms that the framework excludes.

Original: Perhaps the most stringent restrictions are on the arithmetics we allow in ReSolve .
Revised: Perhaps the most stringent restrictions are on the arithmetics we allow in ReSolve .

Original: Using two examples, we illustrate some limits of our framework.
Revised: Using two examples, we illustrate some limits of our framework.

Original: One simple (but perhaps unnatural) problem that the proposed framework cannot handle directly is the following: given n items with unknown “rewards” r i , ﬁnd the two items with the maximum product of their rewards ( r i r j ).
Revised: One simple (but perhaps unnatural) problem that the proposed framework cannot handle directly is the following: given n items with unknown “rewards” r i , find the two items with the maximum product of their rewards ( r i r j ).

Original: Computing the product of rewards involves multiplying (instead of adding) unknown parameters, which our framework cannot handle directly.
Revised: Computing the product of rewards involves multiplying (instead of adding) unknown parameters, which our framework cannot handle directly.

Original: On the other hand, the problem is equivalent to maximizing the sum of the logarithm of the two rewards.
Revised: On the other hand, the problem is equivalent to maximizing the sum of the logarithm of the two rewards.

Original: Thus, in this case, a simple reformulation of the problem makes it amenable to Branch & Learn (though whether the learning would work well is a different question, and depends on the data and the parameters).
Revised: Thus, in this case, a simple reformulation of the problem makes it amenable to Branch & Learn (though whether the learning would work well is a different question, and depends on the data and the parameters).

Original: However, we can make the problem and objective slightly more complicated (and contrived): choose 3 items, and maximize the sum of pairwise products of rewards, i.e. ﬁnd items i, j, k to maximize r i r j + r j r k + r i r k .
Revised: However, we can make the problem and objective slightly more complicated (and contrived): choose 3 items, and maximize the sum of pairwise products of rewards, i.e. find items i, j, k to maximize r i r j + r j r k + r i r k .

Original: It is much less obvious how we can ﬁnd a natural reformulation of the problem that makes it still amenable to Branch & Learn, illustrating some of the limits of the approach.
Revised: It is much less obvious how we can find a natural reformulation of the problem that makes it still amenable to Branch & Learn, illustrating some of the limits of the approach.

Original:  The Branch & Learn Framework
Revised:  The Branch & Learn Framework

Original: The proposed Branch & Learn (B&L) framework methodically transforms a recursive algorithm ( ReSolve in Algorithm 2) as described in the last section into a Predict+Optimize learning algorithm.
Revised: The proposed Branch & Learn (B&L) framework methodically transforms a recursive algorithm ( ReSolve in Algorithm 2) as described in the last section into a Predict+Optimize learning algorithm.

Original: In particular, we adapt the recursive algorithm into the ReLearn template of Algorithm 2, for use as the Convert function (line 7)—the intellectual core of the approach—in Algorithm 1.
Revised: In particular, we adapt the recursive algorithm into the ReLearn template of Algorithm 2, for use as the Convert function (line 7)—the intellectual core of the approach—in Algorithm 1.

Original: Recall from Section 2 that, in the context of the coordinate descent algorithm (Algorithm 1), Convert ( ReLearn here) takes as input i) the problem P  —constructed from P as well as the current training example ( A, ✓ ) —the problem P expressed as a function of the free coefﬁcient coordinate  , and ii) the domain I 0 of  , also constructed from ( A, ✓ ) (for example, to ensure basic properties of parameters such as non-negativity).
Revised: Recall from Section 2 that, in the context of the coordinate descent algorithm (Algorithm 1), Convert ( ReLearn here) takes as input i) the problem P γ —constructed from P as well as the current training example ( A, θ ) —the problem P expressed as a function of the free coefficient coordinate γ , and ii) the domain I 0 of γ , also constructed from ( A, θ ) (for example, to ensure basic properties of parameters such as non-negativity).

Original: From these inputs, ReLearn computes a piecewise linear function, mapping intervals (that partition I 0 overall) to objectives (computed under the estimated parameters) of estimated optimal solutions using  taking values within that interval.
Revised: From these inputs, ReLearn computes a piecewise linear function, mapping intervals (that partition I 0 overall) to objectives (computed under the estimated parameters) of estimated optimal solutions using γ taking values within that interval.

Original: To construct such a ReLearn procedure, we can simply adapt from the corresponding ReSolve algorithm, and we explain each component of ReLearn here.
Revised: To construct such a ReLearn procedure, we can simply adapt from the corresponding ReSolve algorithm, and we explain each component of ReLearn here.

Original: ReSolve (Algorithm 2) comprises isBaseCase , BaseCaseL , ExtractL , BranchL , Map and Reduce .
Revised: ReSolve (Algorithm 2) comprises isBaseCase , BaseCaseL , ExtractL , BranchL , Map and Reduce .

Original: Since isBaseCase , Map and Reduce do not directly involve any parameters, they are unchanged from ReSolve .
Revised: Since isBaseCase , Map and Reduce do not directly involve any parameters, they are unchanged from ReSolve .

Original: As for BaseCaseL , ExtractL and BranchL , they are obtained from ReSolve by replacing all arithmetic operations with their piecewise linear generalizations.
Revised: As for BaseCaseL , ExtractL and BranchL , they are obtained from ReSolve by replacing all arithmetic operations with their piecewise linear generalizations.

Original: With these component functions, the structure of ReLearn can then be based on that of ReSolve .
Revised: With these component functions, the structure of ReLearn can then be based on that of ReSolve .

Original: ReLearn ﬁrst checks whether the current subproblem is a base case, and if so, returns the corre- sponding objective under the estimated parameters.
Revised: ReLearn first checks whether the current subproblem is a base case, and if so, returns the corre- sponding objective under the estimated parameters.

Original: Otherwise, it performs the recursion as follows: i) ExtractL computes information T  for deciding which subproblems to branch into, where crucially this information will depend on the parameters and hence also on the free coefﬁcient  .
Revised: Otherwise, it performs the recursion as follows: i) ExtractL computes information T γ for deciding which subproblems to branch into, where crucially this information will depend on the parameters and hence also on the free coefficient γ .

Original: Thus the result of ExtractL is a data structure mapping each disjoint subinterval
Revised: Thus the result of ExtractL is a data structure mapping each disjoint subinterval

Original: I of I 0 to some information
Revised: I of I 0 to some information

Original: T  [ I ] .
Revised: T γ [ I ] .

Original: In ReLearn , we denote the set of subintervals as I ( T  ) .
Revised: In ReLearn , we denote the set of subintervals as I ( T γ ) .

Original: ii)
Revised: ii)

Original: With the result of ExtractL , we iterate over each I 2 I ( T  ) , and perform the corresponding BranchL , Map and Reduce to get the estimated objective values for each  2 I .
Revised: With the result of ExtractL , we iterate over each I ∈ I ( T γ ) , and perform the corresponding BranchL , Map and Reduce to get the estimated objective values for each γ ∈ I .

Original: Note that, since we map ReLearn instead of ReSolve to PL , even within the current interval I , the ﬁnal estimated objective will generally be further subdivided into smaller pieces.
Revised: Note that, since we map ReLearn instead of ReSolve to PL , even within the current interval I , the final estimated objective will generally be further subdivided into smaller pieces.

Original: Thus, within I , it will be piecewise linear function instead of just a linear function.
Revised: Thus, within I , it will be piecewise linear function instead of just a linear function.

Original: Reduce , using the canonical piecewise linear extension  of  , handles the further subdivisions as desired.
Revised: Reduce , using the canonical piecewise linear extension ⊞ of ⊕ , handles the further subdivisions as desired.

Original: iii)
Revised: iii)

Original: Finally, the resulting piecewise linear function R [ I ] is returned.
Revised: Finally, the resulting piecewise linear function R [ I ] is returned.

Original: Example 3.
Revised: Example 3.

Original: The adapted ReLearn_KS in Algorithm 3 solves the parameterized 0-1 knapsack problem with the inputs of the parameterized problem P i
Revised: The adapted ReLearn_KS in Algorithm 3 solves the parameterized 0-1 knapsack problem with the inputs of the parameterized problem P iγ =

Original:  = ( p  , c, n, W, S ) and an initial domain
Revised: ( p γ , c, n, W, S ) and an initial domain

Original: I 0 .
Revised: I 0 .

Original: The estimated proﬁts p  is an array of linear functions of the free coefﬁcient  , and I 0 is the initial domain depending on A i such that p   0 for all  2 I 0 .
Revised: The estimated profits p γ is an array of linear functions of the free coefficient γ , and I 0 is the initial domain depending on A i such that p γ ≥ 0 for all γ ∈ I 0 .

Original: The components of ReLearn_KS are essentially the same as those of ReSolve_KS (Algorithm 3), except that the addition in lineand the max operation in the Reduce function are replaced by their canonical extensions.
Revised: The components of ReLearn_KS are essentially the same as those of ReSolve_KS (Algorithm 3), except that the addition in lineand the max operation in the Reduce function are replaced by their canonical extensions.

Original: We also note that, while it is possible to completely formalize the framework into a syntactic transformation, the correctness (or the required restrictions on ReSolve ) of the formalization will depend highly on the precise programming language used (e.g. issues of side effect), and require signiﬁcant low-level work on the level of the grammar of the language, detracting from the key intuitions and principles behind our framework.
Revised: We also note that, while it is possible to completely formalize the framework into a syntactic transformation, the correctness (or the required restrictions on ReSolve ) of the formalization will depend highly on the precise programming language used (e.g. issues of side effect), and require significant low-level work on the level of the grammar of the language, detracting from the key intuitions and principles behind our framework.

Original: For this reason, we do not embark on such formalization in this paper.
Revised: For this reason, we do not embark on such formalization in this paper.

Original: Nonetheless, in the next section, we give several case studies to showcase problems that are amenable to our framework and show how to adapt those recursive/iterative algorithms to ReLearn functions, demonstrating the applicability of the proposed framework.
Revised: Nonetheless, in the next section, we give several case studies to showcase problems that are amenable to our framework and show how to adapt those recursive/iterative algorithms to ReLearn functions, demonstrating the applicability of the proposed framework.

Original:  Case Studies
Revised:  Case Studies

Original: This section gives several case studies for our framework.
Revised: This section gives several case studies for our framework.

Original: We ﬁrst demonstrate, using the example of the shortest path problem (SPP), how our framework can recover the DP based method of Demirovi´c et al.
Revised: We first demonstrate, using the example of the shortest path problem (SPP), how our framework can recover the DP based method of Demirovi ´ c et al.

Original: We then showcase our framework on a more complicated iterative algorithm for solving the capacitated minimum cost ﬂow problem (MCFP).
Revised: We then showcase our framework on a more complicated iterative algorithm for solving the capacitated minimum cost flow problem (MCFP).

Original: To demonstrate the full recursion generality that our framework can handle, we use it on the tree-search algorithm for the NP -hard problem of minimum cost vertex cover (MCVC).
Revised: To demonstrate the full recursion generality that our framework can handle, we use it on the tree-search algorithm for the NP -hard problem of minimum cost vertex cover (MCVC).

Original: The last example is the multi-stage scheduling (MSS) problem, which can be handled by our framework straightforwardly but not by many other prior Predict+Optimize methods.
Revised: The last example is the multi-stage scheduling (MSS) problem, which can be handled by our framework straightforwardly but not by many other prior Predict+Optimize methods.

Original: We describe the problems in the main paper while details are given in Appendix A.
Revised: We describe the problems in the main paper while details are given in Appendix A.

Original: Shortest Path Tabular DP can be viewed as an iterative algorithm, computing the subproblem table row by row—the Branch operation in ReSolve generates a single subproblem P 0 , which is independent of the unknown parameters (only the parameters to P 0 depend on the unknown parameters).
Revised: Shortest Path Tabular DP can be viewed as an iterative algorithm, computing the subproblem table row by row—the Branch operation in ReSolve generates a single subproblem P ′ , which is independent of the unknown parameters (only the parameters to P ′ depend on the unknown parameters).

Original: With this perspective, the work of Demirovi´c et al.
Revised: With this perspective, the work of Demirovi´c et al.

Original: [5] is a special case of our method.
Revised: [5] is a special case of our method.

Original: A concrete example is the Bellman-Ford algorithm [2] for SPP in a weighted directed graph with potentially negative weights.
Revised: A concrete example is the Bellman-Ford algorithm [2] for SPP in a weighted directed graph with potentially negative weights.

Original: We instantiate ReSolve for solving SPP to obtain ReSolve_SPP as follows.
Revised: We instantiate ReSolve for solving SPP to obtain ReSolve_SPP as follows.

Original: Suppose V is the set of vertices of the graph.
Revised: Suppose V is the set of vertices of the graph.

Original: The inputs of ReSolve_SPP are ( G c , D, s, t, N ) , where G c 2 R | V | ⇥ | V | is a matrix with entry ( G c ) uv equal to the cost along the directed edge uv , N is a counter, D is an array of shortest ( | V |  N  1) -hop distances from the source to each vertex, and s and t are the source and terminal.
Revised: The inputs of ReSolve_SPP are ( G c , D, s, t, N ) , where G c ∈ R | V |×| V | is a matrix with entry ( G c ) uv equal to the cost along the directed edge uv , N is a counter, D is an array of shortest ( | V | − N − 1) -hop distances from the source to each vertex, and s and t are the source and terminal.

Original: Initially, N = | V |  1 and all elements in D are initialized to a sufﬁciently large number (signifying inﬁnity), except that D [ s ] is set to 0 .
Revised: Initially, N = | V | − 1 and all elements in D are initialized to a sufficiently large number (signifying infinity), except that D [ s ] is set to 0 .

Original: isBaseCase_SPP tests whether N = 0 , and BaseCase_SPP returns D [ t ] .
Revised: isBaseCase_SPP tests whether N = 0 , and BaseCase_SPP returns D [ t ] .

Original: Extract_SPP computes an array D 0 where each element D 0 [ v ] is computed by iterating over every vertex u 6 = v and computing D [-
-]
Revised: Extract_SPP computes an array D ′ where each element D ′ [ v ] is computed by iterating over every vertex u ̸ = v and computing D [-
-]′

Original: [ v ] = min( D [ v ] , D [ u ] + ( G c ) uv ) .
Revised: [ v ] = min ( D [ v ] , D [ u ] + ( G c ) uv ) .

Original: Branch_SPP returns a single subproblem [ P 0 ] where P 0 =
Revised: Branch_SPP returns a single subproblem [ P ′ ] where P ′ =

Original: ( G c , D 0 , s, t, N  1) , on which ReSolve_SPP is called recursively.
Revised: ( G c , D ′ , s, t, N − 1) , on which ReSolve_SPP is called recursively.

Original: We consider the Predict+Optimize setting where the edge costs are unknown.
Revised: We consider the Predict+Optimize setting where the edge costs are unknown.

Original: In the parameterized problem P  , parameterized by the free coefﬁcient  in the coordinate descent, the edge costs are non-negative parameters represented by linear functions of  .
Revised: In the parameterized problem P γ , parameterized by the free coefficient γ in the coordinate descent, the edge costs are non-negative parameters represented by linear functions of γ .

Original: Correspondingly, all operations in
Revised: Correspondingly, all operations in

Original: ReLearn_SPP involving edge costs are replaced by their piecewise linear counterparts (Section 2).
Revised: ReLearn_SPP involving edge costs are replaced by their piecewise linear counterparts (Section 2).

Original: ReLearn_SPP outputs a piecewise linear function that is the cost of the estimated shortest path under the estimated parameters, which as explained in Section 2 can be used to compute the regret.
Revised: ReLearn_SPP outputs a piecewise linear function that is the cost of the estimated shortest path under the estimated parameters, which as explained in Section 2 can be used to compute the regret.

Original: See Appendix A.1 for the pseudocode of ReSolve_SPP and ReLearn_SPP .
Revised: See Appendix A.1 for the pseudocode of ReSolve_SPP and ReLearn_SPP .

Original: Capacitated Minimum Cost Flow We now apply the B&L framework to another iteratively solvable problem: MCFP in a directed graph, where at most one edge exists between any two vertices.
Revised: Capacitated Minimum Cost Flow We now apply the B&L framework to another iteratively solvable problem: MCFP in a directed graph, where at most one edge exists between any two vertices.

Original: Each graph edge has a non-negative capacity and a non-negative cost per unit of ﬂow.
Revised: Each graph edge has a non-negative capacity and a non-negative cost per unit of flow.

Original: Given input K , we want to ﬁnd the least cost to route K units of ﬂow from the source s to the terminal t .
Revised: Given input K , we want to find the least cost to route K units of flow from the source s to the terminal t .

Original: We consider the parameterized problem where only the edge ﬂow costs are unknown.
Revised: We consider the parameterized problem where only the edge flow costs are unknown.

Original: We instantiate ReSolve for solving MCFP using the successive shortest path algorithm
Revised: We instantiate ReSolve for solving MCFP using the successive shortest path algorithm

Original: [16], to obtain ReSolve_MCFP .
Revised: [16], to obtain ReSolve_MCFP .

Original: Suppose the set of vertices is V .
Revised: Suppose the set of vertices is V .

Original: The inputs of ReSolve_MCFP are ( G p , G c , F, s, t ) .
Revised: The inputs of ReSolve_MCFP are ( G p , G c , F, s, t ) .

Original: The two matrices G p 2 R | V | ⇥ | V |and G c 2 R
Revised: The two matrices G p ∈ R | V |×| V |

Original:  | V | ⇥ | V | represent the edge capacity and the edge (unit) ﬂow cost of the graph respectively.
Revised: ≥and G c ∈ R | V |×| V | ≥represent the edge capacity and the edge (unit) flow cost of the graph respectively.

Original: For the successive shortest path algorithm, we preprocess the graph by adding, for every edge uv in G , a reverse edge vu with 0 capacity and the negated cost  ( G c ) uv .
Revised: For the successive shortest path algorithm, we preprocess the graph by adding, for every edge uv in G , a reverse edge vu with 0 capacity and the negated cost − ( G c ) uv .

Original: The variable F 2 R | V | ⇥ | V | is a matrix representing the ﬂow sent along each edge so far.
Revised: The variable F ∈ R | V |×| V | ≥is a matrix representing the flow sent along each edge so far.

Original: isBaseCase_MCFP tests whether there is no longer a path from s to t with non-zero capacity in G p or whether the sum of all ﬂows sent to t is no less than K , and BaseCase_MCFP adds the costs of all ﬂows in F , i.e. R = 
Revised: isBaseCase_MCFP tests whether there is no longer a path from s to t with non-zero capacity in G p or whether the sum of all flows sent to t is no less than K , and BaseCase_MCFP adds the costs of all flows in F , i.e. R = (cid:80) ( u,v ) F uv · ( G c ) uv .

Original: P ( u,v ) F uv · ( G c ) uv . Extract_MCFP computes a path T from s to t with lowest cost (per unit ﬂow) in G c .
Revised: Extract_MCFP computes a path T from s to t with lowest cost (per unit flow) in G c .

Original: Branch_MCFP updates the capacity graph G p and the ﬂow graph F given a path T .
Revised: Branch_MCFP updates the capacity graph G p and the flow graph F given a path T .

Original: The capacity of each edge in the path T is decreased and the capacities of the reverse edges in G p are increased by the value of the sending ﬂow.
Revised: The capacity of each edge in the path T is decreased and the capacities of the reverse edges in G p are increased by the value of the sending flow.

Original: The value of the sending ﬂow is the minimum value between the largest ﬂow value allowed on T and the remaining ﬂow need to be sent to t .
Revised: The value of the sending flow is the minimum value between the largest flow value allowed on T and the remaining flow need to be sent to t .

Original: The ﬂow is also added to F .
Revised: The flow is also added to F .

Original: ReSolve_MCFP is called recursively on these new G p and F as well as the original G c , s and t .
Revised: ReSolve_MCFP is called recursively on these new G p and F as well as the original G c , s and t .

Original: Correspondingly in ReLearn_MCFP , the input is a problem P  parameterized by the free coefﬁcient  , and all edge costs (the unknown parameters) are expressed as linear functions of  .
Revised: Correspondingly in ReLearn_MCFP , the input is a problem P γ parameterized by the free coefficient γ , and all edge costs (the unknown parameters) are expressed as linear functions of γ .

Original: The initial domain I 0 for  is restricted so that the edge cost estimates are non-negative for all  2 I 0 .
Revised: The initial domain I 0 for γ is restricted so that the edge cost estimates are non-negative for all γ ∈ I 0 .

Original: ExtractL_MCFP adapts from the Bellman-Ford ReLearn_SPP in the previous case study, which computes a piecewise data structure T  mapping intervals (for  ) to different shortest paths (in addition to just the path lengths).
Revised: ExtractL_MCFP adapts from the Bellman-Ford ReLearn_SPP in the previous case study, which computes a piecewise data structure T γ mapping intervals (for γ ) to different shortest paths (in addition to just the path lengths).

Original: For each interval I of T  , Branch_MCFP constructs a subproblem
Revised: For each interval I of T γ , Branch_MCFP constructs a subproblem

Original: P 0  by updating G p using T  [ I ] .
Revised: P ′ γ by updating G p using T γ [ I ] .

Original: ReLearn_MCFP is recursively called on P 0  , until the base case is reached.
Revised: ReLearn_MCFP is recursively called on P ′ γ , until the base case is reached.

Original: See Appendix A.2 for the pseudocode of ReSolve_MCFP and ReLearn_MCFP .
Revised: See Appendix A.2 for the pseudocode of ReSolve_MCFP and ReLearn_MCFP .

Original: Minimum Cost Vertex Cover Our third example is the MCVC problem, where we show how to apply our framework to a (non-degenerate) recursive algorithm (with multiple branches).
Revised: Minimum Cost Vertex Cover Our third example is the MCVC problem, where we show how to apply our framework to a (non-degenerate) recursive algorithm (with multiple branches).

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

Original: ( V, E ) , there is an associated cost c 2 R | V | denoting the cost of picking each vertex.
Revised: ( V, E ) , there is an associated cost c ∈ R | V | denoting the cost of picking each vertex.

Original: The costs are unknown parameters.
Revised: The costs are unknown parameters.

Original: The goal is to pick a subset of vertices, minimizing the total cost, subject to the constraint that all edges need to be covered, namely at least one of the two vertices on an edge needs to be picked.
Revised: The goal is to pick a subset of vertices, minimizing the total cost, subject to the constraint that all edges need to be covered, namely at least one of the two vertices on an edge needs to be picked.

Original: This problem is relevant in applications such as building public facilities.
Revised: This problem is relevant in applications such as building public facilities.

Original: Consider, for example, the graph being a road network with edge values being trafﬁc ﬂow, and we wish to build speed cameras at intersections with minimum cost, while covering all the roads.
Revised: Consider, for example, the graph being a road network with edge values being traffic flow, and we wish to build speed cameras at intersections with minimum cost, while covering all the roads.

Original: The recursive algorithm ReSolve_MCVC takes input ( G, c, ` , n, chosen ) , where G, c, ` are as before, n is the number of levels of (binary) recursion remaining and chosen is the current list of chosen vertices.
Revised: The recursive algorithm ReSolve_MCVC takes input ( G, c, ℓ, n, chosen ) , where G, c, ℓ are as before, n is the number of levels of (binary) recursion remaining and chosen is the current list of chosen vertices.

Original: isBaseCase_MCVC checks if n = 0 , and BaseCase_MCVC returns the total cost of vertices in chosen if all edges in G are covered, and returns inﬁnity otherwise.
Revised: isBaseCase_MCVC checks if n = 0 , and BaseCase_MCVC returns the total cost of vertices in chosen if all edges in G are covered, and returns infinity otherwise.

Original: Extract_MCVC is a no-op.
Revised: Extract_MCVC is a no-op.

Original: Branch_MCVC creates two subproblems ( G, c, ` , n  1 , chosen ) and ( G, c, ` , n  1 , chosen [ { n } ) , i.e. choosing vertex n or not, and Reduce takes the min of the two op- tions.
Revised: Branch_MCVC creates two subproblems ( G, c, ℓ, n − 1 , chosen ) and ( G, c, ℓ, n − 1 , chosen ∪{ n } ) , i.e. choosing vertex n or not, and Reduce takes the min of the two options.

Original: Correspondingly, ReLearn_MCVC replaces all arithmetic and min operations by piecewise linear counterparts.
Revised: Correspondingly, ReLearn_MCVC replaces all arithmetic and min operations by piecewise linear counterparts.

Original: See Appendix A.3 for the pseudocode of ReSolve_MCVC and ReLearn_MCVC .
Revised: See Appendix A.3 for the pseudocode of ReSolve_MCVC and ReLearn_MCVC .

Original: Multi-stage Scheduling Our last example is the MSS problem, where a set of items needs to be processed by two machines sequentially.
Revised: Multi-stage Scheduling Our last example is the MSS problem, where a set of items needs to be processed by two machines sequentially.

Original: Each machine can process only one item at a time, and each item must be processed ﬁrst by machine 1 and then machine 2.
Revised: Each machine can process only one item at a time, and each item must be processed first by machine 1 and then machine 2.

Original: Furthermore, the items must be processed by both machines in the same order.
Revised: Furthermore, the items must be processed by both machines in the same order.

Original: The goal is to ﬁnd an ordering for processing items that minimizes the total elapsed time.
Revised: The goal is to find an ordering for processing items that minimizes the total elapsed time.

Original: For this problem, the unknown parameters are the individual item processing times on the machines.
Revised: For this problem, the unknown parameters are the individual item processing times on the machines.

Original: We note that a host of prior Predict+Optimize methods cannot be applied to this problem, including the tabular DP method of Demirovi´c et al.
Revised: We note that a host of prior Predict+Optimize methods cannot be applied to this problem, including the tabular DP method of Demirovi´c et al.

Original: [5], as well as the recent work of Guler et al.
Revised: [5], as well as the recent work of Guler et al.

Original: [9] and any linear programming based methods which all require a problem formulation with an objective that is bilinear in the unknown parameters and the decision variables (that is, a dot product between these two vectors).
Revised: [9] and any linear programming based methods which all require a problem formulation with an objective that is bilinear in the unknown parameters and the decision variables (that is, a dot product between these two vectors).

Original: Our method on the other hand handles this problem relatively straightforwardly by directly adapting Johnson’s rule.
Revised: Our method on the other hand handles this problem relatively straightforwardly by directly adapting Johnson’s rule.

Original: See Appendix A.4 for details of ReSolve_MSS and ReLearn_MSS as well as their pseudocode.
Revised: See Appendix A.4 for details of ReSolve_MSS and ReLearn_MSS as well as their pseudocode.

Original:  Comparing Branch & Learn with Latest Work
Revised:  Comparing Branch & Learn with Latest Work

Original: Both Branch & Learn and the work of Guler et al.
Revised: Both Branch & Learn and the work of Guler et al.

Original: [9] are exact methods for Predict+Optimize, since they both directly optimize the regret, instead of any surrogates.
Revised: [9] are exact methods for Predict+Optimize, since they both directly optimize the regret, instead of any surrogates.

Original: Both also use coordinate-descent as the high-level optimization routine.
Revised: Both also use coordinate-descent as the high-level optimization routine.

Original: The main differences lie in the kind of problems that the methods can apply to, as well as the very different techniques used to achieve each coordinate-descent step.
Revised: The main differences lie in the kind of problems that the methods can apply to, as well as the very different techniques used to achieve each coordinate-descent step.

Original: In terms of applicable problems, Branch & Learn applies to all optimization problems solvable by an algorithm ﬁtting the ReSolve template in Section 3.
Revised: In terms of applicable problems, Branch & Learn applies to all optimization problems solvable by an algorithm fitting the ReSolve template in Section 3.

Original: On the other hand, [9] applies to problems with an objective that is bilinear in both the decision variables and the unknown parameters—the objective is the inner product between the two vectors.
Revised: On the other hand, [9] applies to problems with an objective that is bilinear in both the decision variables and the unknown parameters—the objective is the inner product between the two vectors.

Original: There are problems amenable to Branch & Learn but not [9], and vice versa.
Revised: There are problems amenable to Branch & Learn but not [9], and vice versa.

Original: Here we can give some intuition about when each method is applicable.
Revised: Here we can give some intuition about when each method is applicable.

Original: Suppose we have an optimization problem with a ﬁnite feasible solution set.
Revised: Suppose we have an optimization problem with a finite feasible solution set.

Original: For most practical purposes, such a solution set is enumerable by a recursive algorithm (but not always, since ﬁnite sets need not be enumerable for computability reasons).
Revised: For most practical purposes, such a solution set is enumerable by a recursive algorithm (but not always, since finite sets need not be enumerable for computability reasons).

Original: If, additionally, the objective function is bilinear as in the assumption of [9], then Branch & Learn would be able to handle such a problem.
Revised: If, additionally, the objective function is bilinear as in the assumption of [9], then Branch & Learn would be able to handle such a problem.

Original: In this sense, an optimization problem with a ﬁnite solution set that is solvable by [9] would also be solvable by Branch & Learn.
Revised: In this sense, an optimization problem with a finite solution set that is solvable by [9] would also be solvable by Branch & Learn.

Original: The multi-stage scheduling problem with unknown per-item/machine processing times is an example problem with no such bilinear-objective representation (unless we use an exponentially large integer linear program to represent the problem, with exponentially many unknown parameters), yet is easy to ﬁt into our framework.
Revised: The multi-stage scheduling problem with unknown per-item/machine processing times is an example problem with no such bilinear-objective representation (unless we use an exponentially large integer linear program to represent the problem, with exponentially many unknown parameters), yet is easy to fit into our framework.

Original: On the other hand, if the solution space is continuous, Branch & Learn might not be able to handle such an optimization problem.
Revised: On the other hand, if the solution space is continuous, Branch & Learn might not be able to handle such an optimization problem.

Original: The reason is that Branch & Learn (as it is currently formulated) requires explicitly computing the entire empirical regret function, which is possible only if the regret has a ﬁnite representation (say, as a piecewise linear function).
Revised: The reason is that Branch & Learn (as it is currently formulated) requires explicitly computing the entire empirical regret function, which is possible only if the regret has a finite representation (say, as a piecewise linear function).

Original: When the solution space is continuous, the regret might be a general smooth function even if the objective is bilinear.
Revised: When the solution space is continuous, the regret might be a general smooth function even if the objective is bilinear.

Original: By contrast, [9] never computes the entire regret function explicitly.
Revised: By contrast, [9] never computes the entire regret function explicitly.

Original: Instead, it just computes the regret function at query points, and performs numerical optimization on the function (which is convex when the objective is bilinear).
Revised: Instead, it just computes the regret function at query points, and performs numerical optimization on the function (which is convex when the objective is bilinear).

Original: In this sense, [9] is more capable than Branch & Learn in these continuous settings.
Revised: In this sense, [9] is more capable than Branch & Learn in these continuous settings.

Original: In terms of techniques, Branch & Learn automatically generates the “transition points” in the piecewise linear functions by essentially simulating the recursive algorithm.
Revised: In terms of techniques, Branch & Learn automatically generates the “transition points” in the piecewise linear functions by essentially simulating the recursive algorithm.

Original: This contrasts the approach of [9], where they leverage the convexity structure in the problem arising from their bilinearity assumption on the objective, and they use a numerical optimization approach (essentially a variant of binary/ternary search) to perform a coordinate-descent step.
Revised: This contrasts the approach of [9], where they leverage the convexity structure in the problem arising from their bilinearity assumption on the objective, and they use a numerical optimization approach (essentially a variant of binary/ternary search) to perform a coordinate-descent step.

Original:  Experimental Evaluation
Revised:  Experimental Evaluation

Original: In this section, we compare our proposed B&L method with other methods for Predict+Optimize.
Revised: In this section, we compare our proposed B&L method with other methods for Predict+Optimize.

Original: We include 4 classical regression methods: linear regression (LR), k -nearest neighbors ( k -NN), classiﬁcation and regression tree (CART) and random forest (RF) [8]; 3 approximation methods: smart predict then optimize (SPO) [6], quadratic programming task loss (QPTL) [17], and interior point based approach (IntOpt) [12]; and 2 exact methods: SPO tree and SPO forest [7].
Revised: We include 4 classical regression methods: linear regression (LR), k -nearest neighbors ( k -NN), classification and regression tree (CART) and random forest (RF) [8]; 3 approximation methods: smart predict then optimize (SPO) [6], quadratic programming task loss (QPTL) [17], and interior point based approach (IntOpt) [12]; and 2 exact methods: SPO tree and SPO forest [7].

Original: We experiment on three optimization problems: MCFP, MCVC and MSS—problems that the previous DP-based method cannot handle—and use both artiﬁcial and real-life data on real-life graphs.
Revised: We experiment on three optimization problems: MCFP, MCVC and MSS—problems that the previous DP-based method cannot handle—and use both artificial and real-life data on real-life graphs.

Original: For MCFP, we use USANet [11] (24 vertices and 43 edges) and GÉANT [10] (40 vertices and 61 edges).
Revised: For MCFP, we use USANet [11] (24 vertices and 43 edges) and GÉANT [10] (40 vertices and 61 edges).

Original: For the NP -hard problem of MCVC, we use two smaller graphs from the Survivable 
Revised: For the NP -hard problem of MCVC, we use two smaller graphs from the Survivable Network Design

Original: [Table] Library [13]: POLSKA (12 vertices and 18 edges) and PDH (11 vertices and 34 edges).
Revised: Library [13]: POLSKA (12 vertices and 18 edges) and PDH (11 vertices and 34 edges).

Original: In MCFP, the edge costs are unknown, and the capacities are sampled from [10 , 50] .
Revised: In MCFP, the edge costs are unknown, and the capacities are sampled from [10 , 50] .

Original: The ﬂow value is set to 20, and we select random sources and sinks.
Revised: The flow value is set to 20, and we select random sources and sinks.

Original: In MCVC, the edge costs are unknown.
Revised: In MCVC, the edge costs are unknown.

Original: In MSS, the processing times for each item and machine are unknown.
Revised: In MSS, the processing times for each item and machine are unknown.

Original: We vary the number of jobs from 10 to 40.
Revised: We vary the number of jobs from 10 to 40.

Original: [Table] [Table]
Revised: [Table] [Table]

Original: We run 30 simulations for each problem conﬁguration.
Revised: We run 30 simulations for each problem configuration.

Original: In each simulation, we build datasets con- sisting of n 2 { 100 , 300 } pairs of (feature matrix, parameters).
Revised: In each simulation, we build datasets consisting of n ∈ { 100 , 300 } pairs of (feature matrix, parameters).

Original: In the artiﬁcial and real-life datasets, each parameter has 4 and 8 features respectively.
Revised: In the artificial and real-life datasets, each parameter has 4 and 8 features respectively.

Original: Given that we are unable to ﬁnd datasets speciﬁcally for the MCFP, MCVC and MSS problems, we follow the experimental approach of Demirovi´c et al.
Revised: Given that we are unable to find datasets specifically for the MCFP, MCVC and MSS problems, we follow the experimental approach of Demirovi ´ c et al.

Original: [3, 4, 5] and use real data from a different problem (the ICON scheduling competition) as numerical values required for our experiment instances.
Revised: [3, 4, 5] and use real data from a different problem (the ICON scheduling competition) as numerical values required for our experiment instances.

Original: We use a 70%/30% training/testing data split.
Revised: We use a 70%/30% training/testing data split.

Original: Details of the data generation method are in Appendix B.
Revised: Details of the data generation method are in Appendix B.

Original: We use the scikit-learn library [1] to implement LR, k -NN, CART and RF, and OR-Tools [14] as the problem solver in SPO Tree and SPO Forest.
Revised: We use the scikit-learn library [1] to implement LR, k -NN, CART and RF, and OR-Tools [14] as the problem solver in SPO Tree and SPO Forest.

Original: All models are trained with Intel(R)
Revised: All models are trained with Intel(R)

Original: Xeon(R) CPU E5-2630 v2 @ 2.60GHz processors.
Revised: Xeon(R) CPU E5-2630 v2 @ 2.60GHz processors.

Original: Solution Quality Table 1, 2, and 3 report the mean regrets and their standard deviations for each method on MCFP, MCVC and MSS respectively.
Revised: Solution Quality Table 1, 2, and 3 report the mean regrets and their standard deviations for each method on MCFP, MCVC and MSS respectively.

Original: Mean regret ± std is the metric used to demonstrate the performance.
Revised: Mean regret ± std is the metric used to demonstrate the performance.

Original: At the bottom of the table we also report the average true optimal values (TOV) to compare the relative error on the artiﬁcial and real-life datasets.
Revised: At the bottom of the table we also report the average true optimal values (TOV) to compare the relative error on the artificial and real-life datasets.

Original: As shown in Table 1, B&L achieves the best performance in all cases.
Revised: As shown in Table 1, B&L achieves the best performance in all cases.

Original: On the artiﬁcial dataset, B&L, LR, k -NN, RF, IntOpt, and SPO Forest achieve similar performance on both of the two graphs, while
Revised: On the artificial dataset, B&L, LR, k -NN, RF, IntOpt, and SPO Forest achieve similar performance on both of the two graphs, while

Original: SPO Tree performs well on USANet but has a poor performance on GÉANT.
Revised: SPO Tree performs well on USANet but has a poor performance on GÉANT.

Original: With the real-life dataset, B&L shows the most signiﬁcant advantages.
Revised: With the real-life dataset, B&L shows the most significant advantages.

Original: Compared with other methods, B&L obtains 20.38%-58.35% ( n = 100 ) and 11.13%-60.86% ( n = 300 ) smaller regret on USANet, and 12.13%- 54.11% ( n = 100 ) and 18.70%-64.83% ( n = 300 ) smaller regret on GÉANT.
Revised: Compared with other methods, B&L obtains 20.38%-58.35% ( n = 100 ) and 11.13%-60.86% ( n = 300 ) smaller regret on USANet, and 12.13%- 54.11% ( n = 100 ) and 18.70%-64.83% ( n = 300 ) smaller regret on GÉANT.

Original: We observe that all methods achieve smaller relative error with real-life data than with artiﬁcial data.
Revised: We observe that all methods achieve smaller relative error with real-life data than with artificial data.

Original: B&L, for example, achieves 7.46%-15.68% and 1.12%-2.07% relative error with artiﬁcial and real-life data respectively.
Revised: B&L, for example, achieves 7.46%-15.68% and 1.12%-2.07% relative error with artificial and real-life data respectively.

Original: This is consistent with how the artiﬁcial dataset is purposefully designed to be highly non-linear (see Appendix B), and thus harder to learn.
Revised: This is consistent with how the artificial dataset is purposefully designed to be highly non-linear (see Appendix B), and thus harder to learn.

Original: Nevertheless, B&L still achieves the smallest regret.
Revised: Nevertheless, B&L still achieves the smallest regret.

Original: Table 2 shows the results for MCVC.
Revised: Table 2 shows the results for MCVC.

Original: We can see that B&L has the smallest mean regrets in all cases.
Revised: We can see that B&L has the smallest mean regrets in all cases.

Original: On the artiﬁcial dataset, all methods achieve similar good performance on POLSKA, while
Revised: On the artificial dataset, all methods achieve similar good performance on POLSKA, while

Original: CART and all approximation methods perform poorly on PDH.
Revised: CART and all approximation methods perform poorly on PDH.

Original: The performance differences among different methods are larger in the real-life dataset, and the advantages of B&L are more evident.
Revised: The performance differences among different methods are larger in the real-life dataset, and the advantages of B&L are more evident.

Original: B&L obtains 12.95%-59.41% ( n = 100 ) and 5.22%-59.53% ( n = 300 ) smaller regret in POLSKA, and 9.05%-55.26% ( n = 100 ) and 9.71%-52.89% ( n = 300 ) in PDH.
Revised: B&L obtains 12.95%-59.41% ( n = 100 ) and 5.22%-59.53% ( n = 300 ) smaller regret in POLSKA, and 9.05%-55.26% ( n = 100 ) and 9.71%-52.89% ( n = 300 ) in PDH.

Original: Similar to the results of MCFP, all algorithms achieve better performance in the real-life dataset.
Revised: Similar to the results of MCFP, all algorithms achieve better performance in the real-life dataset.

Original: B&L achieves 6.16%-16.86% relative error in the artiﬁcial dataset, and 0.68%-1.51% relative error in the real-life dataset.
Revised: B&L achieves 6.16%-16.86% relative error in the artificial dataset, and 0.68%-1.51% relative error in the real-life dataset.

Original: [Table] [Table]
Revised: [Table] [Table]

Original: We show the mean regrets and standard deviations in the MSS experiment in Table 3.
Revised: We show the mean regrets and standard deviations in the MSS experiment in Table 3.

Original: Note that linear programming based methods including SPO, QPTL and IntOpt are not applicable to this problem as mentioned in Section 5.
Revised: Note that linear programming based methods including SPO, QPTL and IntOpt are not applicable to this problem as mentioned in Section 5.

Original: Due to the space limitation, we only show the results when the number of jobs is 10 and 40—see Appendix C for more results.
Revised: Due to the space limitation, we only show the results when the number of jobs is 10 and 40—see Appendix C for more results.

Original: B&L has the best performance in all cases with the real-life dataset, achieving 0.44%-0.79% relative error compared to the TOV.
Revised: B&L has the best performance in all cases with the real-life dataset, achieving 0.44%-0.79% relative error compared to the TOV.

Original: Contrasting other methods, B&L obtains 14.58%-69.20% ( n = 100 ) and 14.47%-67.73% ( n = 300 ) smaller regret for 10 jobs, and 10.85%-65.85% ( n = 100 ) and 9.84%-56.10% ( n = 300 ) for 40 jobs.
Revised: Contrasting other methods, B&L obtains 14.58%-69.20% ( n = 100 ) and 14.47%-67.73% ( n = 300 ) smaller regret for 10 jobs [Table] and 10.85%-65.85% ( n = 100 ) and 9.84%-56.10% ( n = 300 ) for 40 jobs.

Original: On the artiﬁcial dataset, all algorithms perform essentially the same, achieving 4.69%-9.65% relative error.
Revised: On the artificial dataset, all algorithms perform essentially the same, achieving 4.69%-9.65% relative error.

Original: Scalability/Runtime Learning using regression or approximate methods is fast, but these methods sacriﬁce the accuracy of the learned model, which is the motivation for the line of work on Predict+Optimize.
Revised: Scalability/Runtime Learning using regression or approximate methods is fast, but these methods sacrifice the accuracy of the learned model, which is the motivation for the line of work on Predict+Optimize.

Original: On the other hand, many optimization problems are expensive to solve.
Revised: On the other hand, many optimization problems are expensive to solve.

Original: Although exact methods achieve lower regret, their runtime scalability can be an issue since their learning process requires solving optimization problems multiple times.
Revised: Although exact methods achieve lower regret, their runtime scalability can be an issue since their learning process requires solving optimization problems multiple times.

Original: For a fair comparison, therefore, we compare B&L only with other exact methods: SPO Tree and SPO Forest.
Revised: For a fair comparison, therefore, we compare B&L only with other exact methods: SPO Tree and SPO Forest.

Original: Table 4 shows the average runtime across 30 simulations for different cases.
Revised: Table 4 shows the average runtime across 30 simulations for different cases.

Original: Overall, we observe that B&L scales at least as well as SPO Tree and SPO Forest in most of the cases.
Revised: Overall, we observe that B&L scales at least as well as SPO Tree and SPO Forest in most of the cases.

Original: Of note is the (MSS, 40 jobs, dataset size 100) setting where B&L runs slower than SPO Tree and Forest, due to the fact that MSS is a permutation-based scheduling problem, where B&L takes signiﬁcant training time to explore all the possible predictions.
Revised: Of note is the (MSS, 40 jobs, dataset size 100) setting where B&L runs slower than SPO Tree and Forest, due to the fact that MSS is a permutation-based scheduling problem, where B&L takes significant training time to explore all the possible predictions.

Original: Nonetheless, if we consider the ratio of runtimes between dataset sizes 100 and 300, B&L scales signiﬁcantly better than SPO Tree and Forest with respect to the dataset size.
Revised: Nonetheless, if we consider the ratio of runtimes between dataset sizes 100 and 300, B&L scales significantly better than SPO Tree and Forest with respect to the dataset size.

Original:  Summary
Revised:  Summary

Original: Given a ReSolve function for a recursively or iteratively solvable problem, we propose a systematic approach to synthesize a ReLearn function for learning with the regret loss, by replacing operators in ReSolve with their piecewise linear counterparts.
Revised: Given a ReSolve function for a recursively or iteratively solvable problem, we propose a systematic approach to synthesize a ReLearn function for learning with the regret loss, by replacing operators in ReSolve with their piecewise linear counterparts.

Original: Our proposal is methodical and straightforward to implement.
Revised: Our proposal is methodical and straightforward to implement.

Original: Furthermore, our framework encompasses a wide class of recursive algorithms ( ReSolve functions), as demonstrated by our case studies.
Revised: Furthermore, our framework encompasses a wide class of recursive algorithms ( ReSolve functions), as demonstrated by our case studies.

Original: Most importantly, B&L empirically achieves the lowest regrets against classical machine learning and contemporary Predict+Optimize algorithms with runtime comparable with the latter.
Revised: Most importantly, B&L empirically achieves the lowest regrets against classical machine learning and contemporary Predict+Optimize algorithms with runtime comparable with the latter.

Original: Acknowledgments
Revised: Acknowledgments

Original: We thank the anonymous referees for their constructive comments.
Revised: We thank the anonymous referees for their constructive comments.

Original: In addition, we acknowledge the ﬁnancial support of a General Research Fund (RGC Ref.
Revised: In addition, we acknowledge the financial support of a General Research Fund (RGC Ref.

Original: No. CUHK 14206321) by the University
Revised: No. CUHK 14206321) by the University

Original: Grants Committee, Hong Kong.
Revised: Grants Committee, Hong Kong.

Original: Jasper C.H. Lee was supported in part by the generous funding of a Croucher Fellowship for Postdoctoral Research, NSF award DMS-2023239, NSFMedium Award
Revised: Jasper C.H. Lee was supported in part by the generous funding of a Croucher Fellowship for Postdoctoral Research, NSF award DMS-2023239, NSF