Original: Branch & Learn for Recursively and Iteratively Solvable Problems in Predict+OptimizeAffiliationAddress
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 tackleoptimization problems containing parameters that are unknown at the time ofsolving.
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 satisfyingsimple conditions, we generalize previous work substantially by showing how acorresponding learning algorithm can be constructed directly and methodicallyfrom 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 byviewing 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 showsbetter 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 frameworktackles 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 iscommon 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 maximizingprofit, yet consumer demand is a-priori unknown.
Revised: For example, retailers need to pick items to restock for maximizing proﬁt, yet consumer demand is a-priori unknown.

Original: The task is to i) predict the unknown parameters, then ii) solve the optimization problem usingthe 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 measuresindependent 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 estimatedand 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, andgradient-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 objectiveand 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: Theycan 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 computethe (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] proposea 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 integralobjective 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: Mandyand 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 thestructure 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 tolearn 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 forproblems 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).

Original: We propose a novel exact method for problems solvable with a recursive algorithm (under somerestrictions), significantly 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), signiﬁcantly generalizing the work of Demirovi´c et al.

Original: By viewing iteration as aspecial 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 isimplemented 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 widelyapplicable technique, it is not universal in that many naturally recursively solvable problems are notknown 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 stillfundamentally 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 etal.
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 artificial and real-life data against 9 other learning approachesconfirm the superior solution quality and scalability of our method.
Revised: 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.

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 conqueralgorithm, 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 whoseobjective 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: Whileboth Branch & Learn and [9] are exact methods for Predict+Optimize, there are problems amenableto 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 betweenthe 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 find x ∗ =
Revised: Without loss of generality, an optimization problem is to ﬁnd x ⇤ =

Original: arg min x obj ( x ) s.t. C ( x ) , wherex ∈ R d is a vector of decision variables, obj : R d → R is a function mapping x to a real objectivevalue which is to be minimized, and C is a set of constraints over x .
Revised: arg min x obj ( x ) s.t. C ( x ) , where x 2 R d is a vector of decision variables, 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 solutionand 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 the case where only theobjective 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 extendsthe problem P as follows:
Revised: A parameterized optimization problem (Para-OP) P ( ✓ ) thus extends the problem P as:

Original: [Equation]
Revised: [Equation]

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

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

Original: When the parametersare 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 (cid:80) 4 i =1 p i · x i subject to the budgetconstraint 2 x 1 + 2 x 2 + x 3 + x 4 ≤ 3 , where p is an array representing the profits of projects.
Revised: 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.

Original: Theproblem 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 onlysome 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 θ ∈ R t for a Para-OP are unknown at solving time, andestimated parameters ˆ θ are used instead.
Revised: 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.

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

Original: Theestimation 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 ∈ R t × m is a feature matrix for θ i , so as to yield a predictionfunction f : R t × m → R t for estimating parameters ˆ θ = f ( A ) .
Revised: , ( 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 ) .

Original: The quality of the estimated parameters ˆ θ is measured by the regret function , which is the objectivedifference between the true optimal solution x ∗ ( θ ) and the estimated optimal solution x ∗ (ˆ θ ) underthe 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 define the regret function Regret (ˆ θ, θ ) : 
Revised: Formally, we deﬁne the regret function Regret (ˆ ✓ , ✓ ) : R t ⇥ R t !

Original: R t × R t → R ≥ 0 to be:
Revised: 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 predictionfunction 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 thesolution 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 linearfunction h is a real-valued function defined on a finite set of (closed) intervals I ( h ) partitioning R .
Revised: A piecewise linear function h is a real-valued function deﬁned on a ﬁnite set of (closed) intervals I ( h ) partitioning R .

Original: Each interval I ∈ I ( h ) is associated with a linear function h
Revised: Each interval I 2 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 ∈ R is given by h
Revised: a I r + b I , and the value of h ( r ) for a real number r 2 R is given by h

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

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

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

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

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

Original: All five operations can be computed efficiently by iteratingover intervals of the operands [5].
Revised: All ﬁve operations can be computed efﬁciently 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 formf ( 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 coefficients α ∈ R m .
Revised: A ↵ for some m -dimensional vector of coefﬁcients ↵ 2 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 coefficients α of fiteratively via coordinate descent (Algorithm 1), in which α are initialized arbitrarily and updated ina round-robin fashion.
Revised: [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.

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 coefficient , fixing the other coefficients in α , with an initial domain
Revised: Para-OP as a function of the free coefﬁcient , ﬁxing the other coefﬁcients in ↵ , with an initial domain

Original: I 0 .
Revised: I 0 .

Original: Convert returns a piecewise linear function of the free coefficient from the Para-OP, and eachinterval of the function corresponds to an estimated optimal solution.
Revised: 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.

Original: Evaluate takes the returnedfunction and the true parameters as inputs, computes the estimated optimal value, and obtains theregret as a piecewise constant function of the free coefficient.
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 coefﬁcient.

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

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

Original: . , m } , we replace α k in α with a variable γ ∈ 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  2 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 ∈ R m andb i =
Revised: A i e k 2 R m and b i =

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

Original: Constructsynthesizes 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 profits to be non-negative in Example 1.
Revised: For instance, we may restrict the estimated proﬁts to be non-negative in Example 1.

Original: Convert takes P iγ tocreate 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 ∈ I ( E i ( γ )) , a linear function maps γ to the objective computed withthe estimated parameters a i γ + b i , and the estimated optimal solution x ∗ ( a i γ + b i ) remains the samein each interval 
Revised: 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].

Original: 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 i [ I ] =

Original: Regret ( a i χ ( I ) + b i , θ i ) =
Revised: Regret ( a i  ( I ) + b i , ✓ i ) =

Original: obj ( x ∗ ( a i χ ( I ) + b i ) , θ i ) − obj ( x ∗ ( θ i ) , θ i )
Revised: obj ( x ⇤ ( a i  ( I ) + b i ) , ✓ i )  obj ( x ⇤ ( ✓ i ) , ✓ i )

Original: 1 Function ReSolve ( P, θ ) : if isBaseCase ( P ) then ( x ∗ ( θ ) , C ∗ ( θ )) ← BaseCase( P, θ ) ; else 
Revised: BaseCase ; else T

Original: T ← Extract ( P, θ ) ; PL ← Branch ( P, θ, T ) ; RL ← Map ( ReSolve , PL) ; ( x ∗ ( θ ) , C∗ ( θ ))
Revised: PL C

Original: ← Reduce (⊕ , RL ) ; return[-R 
-]
Revised: Reduce ( ; return[-R 
-]

Original:  Function ReLearn ( P γ , I0 ) : if isBaseCase ( P γ , I 0 ) then
Revised: ; 10 Function ReLearn ( P  , I : if isBaseCase ( P  I 0 ) then

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

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

Original:  do
Revised: ) do

Original: PL← BranchL 
Revised: PL BranchL ( P

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

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

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

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

Original: 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 .
Revised: 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 .

Original: Line 9 sums all L i ( γ ) into a piecewise constant total regret L ( γ ) across all trainingexamples, 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] isto show how to build the Convert function for a tabular DP algorithm, by computing a modified
Revised: [5] is to show how to build the Convert function for a tabular DP algorithm, by computing a modiﬁed

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

Original: In this paper, we significantly generalize the methodby constructing Convert for recursive and iterative algorithms, opening the Predict+Optimizeframework to a much wider class of problems than just those solvable using DP algorithms.
Revised: 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.

Original: A majorobstacle to the generalization is that different prediction coefficients γ can lead to wildly differentexecutions of the recursion, all of which need to be explored in order to optimize for γ minimizing theempirical regret.
Revised: 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.

Original: At a high level, we overcome this challenge by presenting a standard template forrecursive 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 γ .The following sections describe these ideas in detail.
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 coefﬁcient  .

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: Definition 1 (Map) .
Revised: Deﬁnition 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 ∈ D and f ( d i ) ∈ S .
Revised: , d l 2 D and f ( d i ) 2 S .

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

Original: Suppose S is a set and ⊕ : S × S → S is a commutative and associativeoperation.
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 accepts a recursively solvable Para-OP P along with known parameters θ ,and returns the optimal valueC ∗ andoptimal decisions  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 determines if P ( θ ) is a base case, and if so, BaseCase returns the result of P ( θ ) .ii)
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:  Extract , using the current problem P andthe current parameters θ , computes some information Tfrom which  the list of subproblems can be determined.
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 andreturns a list PL of subproblems, andfurther computes their 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 inthe list PL is solved recursively, via Mapmapping 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 abinary operation ⊕ via Reduce .
Revised: After the recursive calls, the partial results in RL are aggregated by a binary operation  via Reduce .

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 theunknown parameters are + , − , max , min and multiplication with known constants, ii) there are noconditionals 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 projectfunding (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 is9 Function i ∈ S ; else the number of remaining projects to consider, W is the remaining funding available, and S is thesetof 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 selected projects so far.

Original: Initially, S = ∅ .
Revised: Initially, S = ; .

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

Original: Branch_KS returns [ P 1 , P 2 ]where P 1 = ( p, c, n − 1 , W, S ) and P 2 = ( p, c, n − 1 , W − c [ n ] , S ∪ { n } ) are two subproblems forwhether the n th project is selected or not, and isBaseCase checks if the total cost exceeds thebudget or if no projects are left to consider.
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. isBaseCase checks if the total cost exceeds the budget or if no projects are left to consider.

Original: As mentioned, the ReSolve template in Algorithm 2 also captures iterative algorithms as recursionwith a single branch. Limitations of requirements on the recursive algorithm Before Example 2, we specified requirements on recursive algorithms that this paper considers.
Revised: Limitations of requirements on the recursive algorithm Before Example 2, we speciﬁed re- quirements on recursive algorithms considered in this paper.

Original: Even though the framework is general, thereexist algorithms that the framework does not apply to.
Revised: Even though the framework is general, there are algorithms that the framework excludes.

Original: Perhaps the most restrictive requirements arethe ones on the arithmetic operations we allow inthe ReSolve algorithm.
Revised: Perhaps the most stringent restrictions are on the arithmetics we allow in ReSolve .

Original: Here, using a couple ofexamples, we illustrate someof the 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 directlyis the following: given n items with unknown “rewards” r i , find the two items with the maximumproduct 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 , ﬁnd the two items with the maximum product of their rewards ( r i r j ).

Original: Computing the product of rewards involves multiplying (instead ofadding) 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, theproblem 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 thelearning 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 more contrived):choose 3 items, and maximize the sum of pairwise products of rewards, as in finding items i, j, k tomaximize 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. ﬁnd items i, j, k to maximize r i r j + r j r k + r i r k .

Original: It becomes much less obvious how we can find a natural reformulationof the problem that makes it still amenable to Branch & Learn, illustrating some of the limits of theapplicability of Branch & Learn.
Revised: 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.

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 asthe 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 thecurrent training example ( A, θ ) , which is the problem P expressed as a function of the free coefficientcoordinate γ , and ii) the domain I 0 of γ , also constructed from ( A, θ ) (for example, to ensure basicproperties 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 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).

Original: From these inputs, ReLearn will compute apiecewise linear function, mapping intervals (that partition I 0 overall) to objectives (computed underthe 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 ReSolvealgorithm, 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 in Algorithm 2 has component functions 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) involveany parameters, they are the same as the ones in 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 can be simply obtained from ReSolve by replacing all numerical operationson theparameters with theirgeneralizations to piecewise linear functions.
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 first checks whether the current subproblem is a base case, and if so, returns the corresponding objective under the estimated parameters.
Revised: ReLearn ﬁrst 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 cruciallythis information will depend on the parameters and hence also on the free coefficient γ .
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 coefﬁcient  .

Original: Thus theresult 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 ∈ I ( T γ ) , and perform the corresponding BranchL , Map and Reduce toget the estimated objective values for each γ ∈ I .
Revised: 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 .

Original: Note that, since we map ReLearn instead of ReSolve to PL , even within the current interval I , the final estimated objective will generally befurther subdivided into smaller pieces.
Revised: 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.

Original: Thus, within I , it will be piecewise linear function instead ofjust 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 thefurther 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 knapsackproblem with the inputs of the parameterized problem P 
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: iγ = ( 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 profits p γ is an array of linear functions of the free coefficient γ , and I 0 is theinitial domain depending on A i such that p γ ≥ 0 for all γ ∈ I 0 .
Revised: 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 .

Original: The components of ReLearn_KSare essentially the same as those of ReSolve_KS (Algorithm 3), except that the addition in line 11and 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 syntactictransformation, the correctness (or the required restrictions on ReSolve ) of the formalizationwill depend highly on the precise programming language used (e.g. issues of side effect), andrequire significant low-level work on the level of the grammar of the language, detracting from thekey 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 signiﬁcant 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 suchformalization 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 showcaseproblems that are amenable to our framework and show how to adapt those recursive/iterativealgorithms 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 of applying the framework.
Revised: This section gives several case studies for our framework.

Original: We first demonstrate, using theexample of  shortest path problem (SPP), how our framework can recover the DP based method by Demirovi ´ c et al.
Revised: 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.

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

Original: To demonstrate the full recursiongenerality that our framework can handle, we use it on therecursive tree-search algorithm for the NPhard 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 otherprior 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 the detailedpseudocodes 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 tablerow by row. In our framework, the Branch operation in ReSolve generates a single subproblem P ′ , which furthermore does not depend on the unknown parameters (only the parameters to P ′depend on the unknown parameters to the current problem).
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 0 , which is independent of the unknown parameters (only the parameters to P 0 depend on the unknown parameters).

Original: With this perspective, the framework 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 withpotentially 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_SPPas 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 ∈ R | V |×| V | is a matrix with entry ( G c ) uv equal to the cost along thedirected edge uv , N is a counter, D is an array of shortest ( | V | − N − 1) -hop distances from thesource 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 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.

Original: Initially, N = | V | − 1 and all elements in D are initialized to a sufficiently large number (signifying infinity), except that D [ s ] is set to0 .
Revised: 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 .

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_SPPcomputes an array D ′ where each element D ′ [ v ] is computed by iterating over every vertex u ̸ = vand computing D ′ [ v ] ={+
+}
Revised: 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 {+
+}

Original: 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 ′ ] where P ′ =
Revised: Branch_SPP returns a single subproblem [ P 0 ] where P 0 =

Original: ( G c , D ′ , s, t, N − 1) , on which ReSolve_SPP is called recursively.
Revised: ( G c , D 0 , 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 parameterizedproblem P γ , parameterized by the free coefficient γ in the coordinate descent, the edge costs arenon-negative parameters represented by linear functions of γ .
Revised: 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  .

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 pathunder 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 iterativelysolvable 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 flow.
Revised: Each graph edge has a non-negative capacity and a non-negative cost per unit of ﬂow.

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

Original: Weconsider the parameterized problem where only the edge flow costs are unknown.
Revised: We consider the parameterized problem where only the edge ﬂow 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_MCFPare ( 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 ∈ R | V |×| V | 
Revised: The two matrices G p 2 R | V | ⇥ | V | and G c 2 R

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

Original: For the successive shortest pathalgorithm, we preprocess the graph by adding, for every edge uv in G , a reverse edge vu with 0capacity 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 ∈ R | V |×| V | ≥is a matrix representing theflow sent along each edge so far.
Revised: The variable F 2 R | V | ⇥ | V | is a matrix representing the ﬂow sent along each edge so far.

Original: isBaseCase_MCFP tests whether there is no longer a pathfrom s to t with non-zero capacity in G p  , and BaseCase_MCFP adds the costs of all flows in F ,i.e. R =(cid:80) ( u,v ) F uv · ( G c ) uv .
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 ﬂows sent to t is no less than K , and BaseCase_MCFP adds the costs of all ﬂows in F , i.e. R =

Original:  Extract_MCFP computes a path T from s to t with lowest cost (perunit flow) in G c .
Revised: 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 .

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

Original: T . The capacity of each edge in the path T is decreased and the capacity of the reverse edges in G pincreased by the  largest flow value allowed on T  .
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 ﬂow. 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 .

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

Original: ReSolve_MCFP iscalled 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 coefficientγ , 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 coefﬁcient  , and all edge costs (the unknown parameters) are expressed as linear functions of  .

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

Original: ExtractL_MCFP adapts from the Bellman-Ford ReLearn_SPP in the previous case study, whichcomputes a piecewise data structure T γ mapping intervals (for γ ) to different shortest paths (inaddition 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 ′ γ by updating G p using T γ [ I ] .
Revised: P 0  by updating G p using T  [ I ] .

Original: ReLearn_MCFP is recursively called on P ′ γ , until the base caseis reached.
Revised: ReLearn_MCFP is recursively called on P 0  , 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 toapply 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 agraph G =
Revised: Given a graph G =

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

Original: Thecosts 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 onan 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 traffic flow, and wewish 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 trafﬁc ﬂow, 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 asbefore, n is the number of levels of (binary) recursion remaining and chosen is the current listof 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 thetotal cost of vertices in chosen if all edges in G are covered, and returns infinity 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 inﬁnity 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 options.
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 op- tions.

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 beprocessed 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, andeach item must be processed first by machine 1 and then machine 2.
Revised: Each machine can process only one item at a time, and each item must be processed ﬁrst by machine 1 and then machine 2.

Original: Furthermore, the items must beprocessed 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 find an ordering for processing itemsthat minimizes the total elapsed time.
Revised: The goal is to ﬁnd an ordering for processing items that minimizes the total elapsed time.

Original: For this problem, the unknown parameters are the individualitem 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 methodscannot 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 asthe 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 aproblem formulation with an objective that is bilinear in the unknown parameters and the decisionvariables (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 handlesthis 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 fordetails 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 coordinatedescent 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 optimizationproblems that the methods can apply to, as well as the very different techniques used to achieve eachcoordinate-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 ofthe applicable problems, Branch & Learn applies to all optimization problems amenable toan optimization algorithm fitting the ReSolve template in Section 3.
Revised: In terms of applicable problems, Branch & Learn applies to all optimization problems solvable by an algorithm ﬁtting the ReSolve template in Section 3.

Original: On the other hand, [9] appliesto optimization problems where the objective function is bilinear in both the decision variables aswell as the unknown parameters, i.e., 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 someintuition 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 finite feasible solution set.
Revised: Suppose we have an optimization problem with a ﬁnite feasible solution set.

Original: For most practicalpurposes, such a solution set is enumerable by a recursive algorithm (but not always, since finitesets 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 ﬁnite sets need not be enumerable for computability reasons).

Original: If, additionally, the objective function isbilinear 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: Inthis sense, an optimization problem with a finite solution set that is solvable by [9] would also besolvable by Branch & Learn.
Revised: In this sense, an optimization problem with a ﬁnite solution set that is solvable by [9] would also be solvable by Branch & Learn.

Original: The multi-stage scheduling problem with unknown per-item/machineprocessing times is an example problem with no such bilinear-objective representation (unless weuse an exponentially large integer linear program to represent the problem, with exponentially manyunknown parameters), yet is easy to fit 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 ﬁt into our framework.

Original: On the other hand, if the solution space is continuous, Branch & Learn might not be able to handlesuch 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 regrethas a finite 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 ﬁnite 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] nevercomputes the entire regret function explicitly.
Revised: By contrast, [9] never computes the entire regret function explicitly.

Original: Instead, it just queries the regret function  andcomputesits values, and then performs numerical optimization on the function (which is convex when theobjective 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 continuoussettings.
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 thepiecewise 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 theapproach of [9], where they leverage the convexity structure in the problem arising from theirbilinearity assumption on the objective, and they use a numerical optimization approach (essentiallya 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: Weinclude 4 classical regression methods including linear regression (LR), k -nearest neighbors ( k -NN),classification and regression tree (CART) and random forest (RF) [8], 3 approximation methodsincluding smart predict then optimize (SPO) [6], quadratic programming task loss (QPTL)[Table]
Revised: 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)

Original: [Table] and interior point based approach (IntOpt) [12], and 2 exact methods, namely SPO tree and SPOforest [7].
Revised: [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 thatthe previous DP-based method cannot handle, and use both artificial and real-life data on real-lifegraphs.
Revised: 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.

Original: For MCFP, we use USANet [11], with 24 vertices and 43 edges, and GÉANT [10], with40 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 
Revised: For the NP -hard problem of MCVC, we use two smaller graphs from the Survivable

Original: Survivable Network Design Library [13]: POLSKA, with 12 vertices and 18 edges, and PDH, with11 vertices and 34 edges.
Revised: [Table] 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: We set the flow value  tobe 20, and  select random source and sink.
Revised: The ﬂow value is set to 20, and we select random sources and sinks.

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

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

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

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

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

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

Original: Given that we are unable to find datasets specificallyfor the MCFP, MCVC and MSS problems, we follow the experimental approach of Demirovi´cet al.
Revised: 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.

Original: [3, 4, 5] and use real data from a different problem (the ICON scheduling competition) asnumerical 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 datasplit.
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 eachmethod 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 demonstratethe 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) tocompare the relative error on the artificial 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 artiﬁcial 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 artificial dataset, B&L, LR, k -NN, RF, IntOpt, and SPO Forest achieve similar performance on both of the two graphs, while
Revised: 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

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-lifedataset, B&L shows the most significant advantages.
Revised: With the real-life dataset, B&L shows the most signiﬁcant advantages.

Original: Compared with other methods, B&L obtains20.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 allmethods achieve smaller relative error with real-life data than with artificial data.
Revised: We observe that all methods achieve smaller relative error with real-life data than with artiﬁcial data.

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

Original: This is consistent with how the artificial dataset is purposefully designed to be highly non-linear (see Appendix B), and thus harder 
Revised: 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.

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

Original: [Table] 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 allcases.
Revised: We can see that B&L has the smallest mean regrets in all cases.

Original: On the artificial dataset, all methods achieve similar good performance on POLSKA, while
Revised: On the artiﬁcial 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 amongdifferent 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 artificial 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 artiﬁcial dataset, and 0.68%-1.51% relative error in the real-life dataset.

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

Original: Note that linearprogramming based methods including SPO, QPTL and IntOpt are not applicable to this problem asmentioned 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 ofjobs 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 withthe 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 othermethods, B&L obtains 14.58%-69.20% ( n = 100 ) and 14.47%-67.73% ( n = 300 ) smaller regret for10 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, and 10.85%-65.85% ( n = 100 ) and 9.84%-56.10% ( n = 300 ) for 40 jobs.

Original: On the artificialdataset, all algorithms perform essentially the same, achieving 4.69%-9.65% relative error.
Revised: On the artiﬁcial 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 methodssacrifice 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 sacriﬁce 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: Althoughexact methods achieve lower regret, their runtime scalability can be an issue since their learningprocess 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 theaverage 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 atleast 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, datasetsize 100) setting where B&L runs slower than SPO Tree and Forest, due to the fact that MSS is apermutation-based scheduling problem, where B&L takes significant training time to explore all thepossible 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 signiﬁcant training time to explore all the possible predictions.

Original: Nonetheless, if we consider the ratio of runtimes between dataset sizes 100 and300, B&L scales significantly 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 signiﬁcantly 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 systematicapproach to synthesize a ReLearn function for learning with the regret loss, by replacing operatorsin 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 straightforwardto 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 empiricallyachieves the lowest regrets against classical machine learning and contemporary Predict+Optimizealgorithms with runtime comparable with the latter.Checklist The checklist follows the references.
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: Please read the checklist guidelines carefully for information onhow to answer these questions.

Original: For each question, change the default [TODO] to [Yes] , [No] , or[N/A] .

Original: You are strongly encouraged to include a justification to your answer , either by referencingthe appropriate section of your paper or providing a brief inline description.

Original: For example:

Original: • Did you include the license to the code and datasets?

Original: [Yes]

Original: • Did you include the license to the code and datasets?

Original: [No] The code and the data areproprietary.•

Original: Did you include the license to the code and datasets?

Original: [N/A] Please do not modify the questions and only use the provided macros for your answers. Note that the Checklist section does not count towards the page limit.
Revised: Acknowledgments

Original: In your paper, please delete this instructionsblock and only keep the Checklist section heading above along with the questions/answers below.

Original: For all authors...

Original: (a) Do the main claims made in the abstract and introduction accurately reflect the paper’s

Original: contributions and scope?

Original: [Yes]

Original: (b) Did you describe the limitations of your work?

Original: [Yes] See Sections 3 and 4(c)

Original: Did you discuss any potential negative societal impacts of your work?

Original: [N/A]

Original: (d) Have you read the ethics review guidelines and ensured that your paper conforms tothem?

Original: [Yes]2.

Original: If you are including theoretical results...

Original: (a) Did you state the full set of assumptions of all theoretical results?

Original: [N/A]

Original: (b) Did you include complete proofs of all theoretical results?

Original: [N/A]

Original: If you ran experiments...

Original: (a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)?

Original: [Yes] See supplemen-

Original: tal material

Original: (b) Did you specify all the training details (e

Original: g., data splits, hyperparameters, how theywere chosen)?

Original: [Yes] See Section

Original: (c) Did you report error bars (e.g., with respect to the random seed after running experi-

Original: ments multiple times)?

Original: [Yes] See Section

Original: (d) Did you include the total amount of compute and the type of resources used (e.g., typeof GPUs, internal cluster, or cloud provider)?

Original: [Yes] See Section

Original: If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...

Original: (a) If your work uses existing assets, did you cite the creators?

Original: [Yes] See Section

Original: (b) Did you mention the license of the assets?

Original: [N/A]

Original: (c) Did you include any new assets either in the supplemental material or as a URL?

Original: [Yes]

Original: We include code and data in supplemental materials.

Original: (d) Did you discuss whether and how consent was obtained from people whose data you’re

Original: using/curating?

Original: [N/A]

Original: (e) Did you discuss whether the data you are using/curating contains personally identifiable

Original: information or offensive content?

Original: [N/A]

Original: If you used crowdsourcing or conducted research with human subjects...

Original: (a) Did you include the full text of instructions given to participants and screenshots, if

Original: applicable?

Original: [N/A]

Original: (b) Did you describe any potential participant risks, with links to Institutional Review

Original: Board (IRB) approvals, if applicable?

Original: [N/A] (c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]
Revised: We thank the anonymous referees for their constructive comments.

Original: A Pseudocode for Case Studies

Original: This section gives pseudocode implementations for the recursive and iterative algorithmic case studiesin the main paper, which includes i) the Bellman-Ford algorithm for the shortest path problem(Algorithms 4 and 5), ii) the successive shortest path algorithm for the minimum cost flow problem(Algorithm 6 and 7), iii) the branching algorithm for the minimum cost vertex covering problem(Algorithm 8 and 9), and iv) the Johnson’s rule for the multi-stage scheduling problem (Algorithm 10and 11).

Original: Note that for the Bellman-Ford and successive shortest path algorithms, Branch only generates onesubproblem.

Original: Thus it is equivalent to invoking the recursive call on the subproblem directly withoutcalling the Map function.

Original: A.1 Pseudocode for the Bellman-Ford Algorithm for Shortest Path

Original: Algorithm

Original: 1 Function ReSolve_SPP ( G c , D, s, t, N ) : if N = 0 then

Original: R ← D [ t ] ; else

Original: D ′ ← Extract_SPP ( G c , D ) ; [ P ′ ] ← Branch_SPP ( G c , D ′ , s, t, N − 1) ;

Original: R ← ReSolve_SPP ( P ′ ) ; return R ; 9 Function Extract_SPP ( G c , D ) : for every vertex u ̸ = v in V do

Original: D ′

Original: [ v ] =

Original: min

Original: ( D [ v ] , D [ u ] + ( G c ) uv ) ; return D ′

Original: 1 Function ReLearn_SPP ( G c γ , D γ , s, t, N, I 0 ) : if N = 0 then

Original: R [ I 0 ] ← D γ [ t ] ; else D ′ γ ← ExtractL_SPP ( G cγ , D γ , I 0 ) ; [ P ′ ] ← BranchL_SPP ( G cγ , D ′ γ , s, t, N − 1) ; R [ I 0 ] ← ReLearn Flow
Revised: In addition, we acknowledge the ﬁnancial support of a General Research Fund (RGC Ref.

Original: 1 Function ReSolve_MCFP ( G p , G c , F, s, t ) : if no path from s to t in G p then

Original: R ← (cid:80) ( u,v ) F uv · ( G c ) uv ; else

Original: T ← Extract_MCFP ( G p , G c , s, t ) ; [ P ′ ] ← Branch_MCFP ( G p , G c , F, T ) ;

Original: R ← ReSolve_MCFP ( P ′ ) ; return R ; 9 Function Extract_MCFP ( G p , G c , s, t ) : for every vertex v in V do for every vertex u ̸ = v in V do if ( G p ) uv > 0 then

Original: D [ v ] ← min( D [ v ] , D [ u ] + ( G c ) uv ) ; if D [ v ] = D [ u ] + ( G c ) uv then

Original: T [ v ] ← u ; return T ; 17 Function Branch_MCFP ( G p , G c , F, T ) : block _ flow = ∞ ; for every vertex v on T [] do u ← T [ v ] ; block _ flow ← min( block _ flow, F uv ) ; for every vertex v on T [] do u ← T [ v ] ; ( G p ′ )

Original: uv ← ( G p ) uv − block _ flow ; ( G p ′ )

Original: vu ← ( G p ) vu + block _ flow ;

Original: F ′ uv ← F uv + block _ flow ; return ( G p ′ , G c , F ′ , s, t ) ;  γ do

Original: ; 10 Function

Original: : for

Original: V do for do each do

Original: return

Original: ; 19 Function

Original: _MCFP p G cγ F γ [ I ] T γ [ I ]) :
Revised: No. CUHK 14206321) by the University

Original: ; for

Original: I do

Original: ; for do block _ flow ; [ I [ I ; return ( G p ′ , G cγ , F ′ γ
Revised: Grants Committee, Hong Kong.

Original: [ I ] , s, t, I ) ;

Original: [-1 Function ReSolve_MCVC ( G, c, ℓ, n, chosen ) : if n = 
-]
Revised: [-1 Function ReSolve_MCVC ( G, c, ℓ, n, chosen ) : if n = 
-]

Original: then if the edges in G are all covered then

Original: R ← 0 ; for every vertex v in chosen [] do

Original: R ← R + c

Original: [ v ] ; return R ; else return ∞ ; else [ P 1 , P 2 ] ← Branch_MCVC

Original: ( G, c, ℓ, n, chosen ) ; [ R 1 , R 2 ] ← Map ( ReSolve_MCVC , [ P 1 , P 2 ]) ;

Original: R ← Reduce ( min , [ R 1 , R 2 ]) ; return R ; 15 Function Branch_MCVC

Original: ( G, c, ℓ, n, chosen ) :

Original: P 1 ← ( G, c, ℓ, n − 1 , chosen ) ;

Original: P 2 ← ( G, c, ℓ, n − 1 , chosen ∪ { n } ) ; return ( P 1 , P 2 ) ;

Original: [-1 Function ReLearn_MCVC ( G, c γ , ℓ γ , n, chosen γ , I 0 ) : if n = 
-]
Revised: [-1 Function ReLearn_MCVC ( G, c γ , ℓ γ , n, chosen γ , I 0 ) : if n = 
-]

Original: then if the edges in G are all covered then

Original: R [ I 0 ] ← 0 ; for every vertex v in chosen γ [] do

Original: R [ I 0 ] ← R [ I 0 ] + c γ [ v ] ; return R [ I 0 ] ; else

Original: R [ I 0 ] ← ∞ ; return R [ I 0 ] ; else [ P 1 , P 2 ] ← BranchL_MCVC ( G, c γ , ℓ γ , n, chosen γ , I 0 ) ; [ R 1 , R 2 ] ← Map ( ReLearn_MCVC , [ P 1 , P 2 ]) ;

Original: R ← Reduce ( min , [ R 1 , R 2 ]) ; return R ; 16 Function BranchL_MCVC (

Original: A.4 Pseudocode for the Johnson’s rule for Multi-stage Scheduling

Original: Suppose schedule is the current array of the scheduled items which is initialized as an array oflength equal to the total number of items and all elements equal to -1, remainingItems is thecurrent list of the unscheduled items, and timeReq is the array with two columns, each containingthe processing times of each item on a machine.

Original: Throughout the execution of the algorithm, theform of schedule always maintains the structure of [ a, b, c ] where a is a sub-array of non- ( − 1)entries corresponding to actual items, b is a sub-array of only − 1 entries, and c is another sub-array of non- ( − 1) entries corresponding to actual items.

Original: The recursive algorithm ReSolve_MSS takesinput ( n, schedule, remainingItems, timeReq ) , where n is the remaining number of levels ofrecursion.

Original: isBaseCase_MSS checks if n = 0 , and BaseCase_MSS returns the total elapsedtime for processing all items on both of the two machines.

Original: Extract_MSS examines all the entriesof timeReq that correspond to items in remainingItems , and finds the smallest entry.

Original: Thisentry corresponds to an ( item, machine ) pair, where machine can be either 1 or 2, and this pairis returned by Extract_MSS .

Original: Given this as input, Branch_MSS first removes the item fromremainingItems , and needs to now insert this item into schedule .

Original: The way it does that is simple:if the entry found by Extract_MSS corresponds to machine 1, it looks for the first -1 entry inschedule from the beginning of the array and replaces it with item .

Original: Otherwise, it instead looks fromthe end of the array backwards for the first -1 entry, and replaces it with item .

Original: Given this processing,

Original: Branch_MSS returns the single subproblem ( n − 1 , schedule, remainingItems, timeReq ) and

Original: ReSolve_MSS is called recursively.

Original: Correspondingly, the input of ReLearn_MSS is a problem P γ parameterized by the free coefficientγ , and the processing time of all items on two machines (the unknown parameters) are expressedas linear functions of γ .

Original: ExtractL_MSS replaces all arithmetic and min operations by piecewiselinear counterparts, which computes a piecewise data structure T γ mapping intervals (for γ ) todifferent inserted items that with the shortest processing time in the remainingItems list anddifferent corresponding machine numbers.

Original: For each interval I of T γ , Branch_MSS constructsa subproblem P ′ γ by updating schedule and remainingItems using T γ [ I ] .

Original: ReLearn_MSS isrecursively called on P ′ γ , until the base case is reached. 1 Function ReSolve_MSS ( n, schedule, remainingItems, timeReq ) : if n then M 1 Time ← 0 ;
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 Medium Award

Original: M 2 Time ← 0 ; every i schedule [] do

Original: M 1 Time ← M 1 Time + timeReq [ i ][1] ; if then

Original: M 2 Time ← M 2 Time timeReq [ i ][2] ; else

Original: M timeReq [ i ][ do

Original: ( n − 1 , schedule, remainingItems, timeReq ) ;

Original: γ do

Original: M timeReq γ [ i ]

Original: M 2 Time

Original: M 2 Time timeReq γ i ]

Original: M

Original: ← M 1 Time timeReq γ

Original: i

Original: R [ I

Original: ] ← M

Original: ; else do

Original: BranchL

Original: return remainingItems

Original: I

Original: : minProTime do i ] do

Original: B Experimental Setting

Original: In this section, we give details about the experimental setting, including the random source andsink selection method used in MCFP, the generation of the artificial dataset for each problem weexperiment on, and the parameters tuning.

Original: The Random Source and Sink Selection Method Used in MCFP We design graph-specificdistributions for taking a random source and a random sink for the minimum cost flow problem(MCFP), with the goal of making sure that the path between the source and the sink is not too short

Original: [Table]

Original: [Table]

Original: (e.g. length 1).

Original: In USANet, we randomly choose the source from vertices { 1 , 2 , 3 , 4 , 5 } and the sinkfrom vertices { 20 , 21 , 22 , 23 , 24 } .

Original: In GÉANT, the source and sink are randomly selected from all thepoints with zero in-degree and zero out-degree respectively.

Original: The Generation of the Artificial Dataset

Original: The artificial datasets for the three problems are generated as follows.

Original: Each feature is a 4-tuple ⃗a uv

Original: = ( a uv 1 , a uv 2 , a uv 3 , a uv 4 ) , where a uv 1 ∈ { 1 , 2 , . .

Original: , 7 }represents the day of the week, a uv 2 ∈ { 1 , 2 , . .

Original: . , 30 } represents the day of the month, anda uv 3 , a uv 4 ∈ [0 , 360] represent the meteorology index and road congestion respectively.

Original: The trueparameters are generated by 10 ∗ sin ( a uv 1 ) ∗ sin ( a uv 2 ) + 100 ∗ sin ( a uv 3 ) ∗ sin ( a uv 4 ) + C , where

Original: C is a large positive constant to ensure the value of each learned parameter is positive.

Original: We use suchnonlinear mapping to compare the performance of our proposed methods and that of other methods.

Original: Parameters Tuning As for the parameters tuning, we try different settings for k-nearest neighbors(k-NN), Random forest (RF), SPO tree (SPOT), and SPO Forest.

Original: In k-NN, we try the regressionmodel with k ∈ { 1 , 3 , 5 } .

Original: As for RF, we try different numbers of trees in the forest n _ estimator ∈{ 10 , 50 , 100 } .

Original: We tune the maximum depths of the tree max _ depth ∈ { 1 , 3 , 10 , 100 } and theminimum weights per node min _ weights ∈ { 5 , 20 , 30 } for SPOT.

Original: For SPO Forest, we tune twoparameters: the maximum depth of each tree max _ depth ∈ { 1 , 3 , 10 , 100 } and the number of treesin the forest n _ estimator ∈ { 10 , 50 , 100 } .

Original: We end this appendix section with a remark on our experiments using real-life data.

Original: Given that weare unable to find datasets specifically for the MCFP, MCVC and MSS problems, we follow theexperimental approach of Demirovi´c et al.

Original: [3, 4, 5] and use real data from a different problem (the

Original: ICON scheduling competition) as numerical values required for our experiment instances.

Original: C Additional Results: Multi-stage Scheduling

Original: This section shows the experiment results of the job number of 10, 20, 30, and 40 in the MSSexperiment with artificial and real-life datasets.

Original: Table 5 reports the mean regrets and their standard deviations for each method on the artificial dataset.

Original: Although all algorithms achieve similar performances, B&L performs (slightly) better than all othermethods in all cases.

Original: The results on the real-life dataset are shown in Table 6.

Original: Compared with theartificial dataset, the performance differences among different methods are larger in the real-lifedataset, and the advantages of B&L are more evident.

Original: Contrasting other methods, B&L obtains14.58%-69.20% ( n = 100 ) and 14.47%-67.73% ( n = 300 ) smaller regret for 10 jobs, 19.45%-73.41%( n = 100 ) and 16.09%-69.45% ( n = 300 ) smaller regret for 20 jobs, 18.56%-68.74% ( n = 100 )and 12.29%-61.74% ( n = 300 ) smaller regret for 30 jobs, and 10.85%-65.85% ( n = 100 ) and9.84%-56.10% ( n = 300 ) for 40 jobs.

Original: Similar to the results of MCFP and MCVC, all algorithmsachieve better performance on the real-life dataset.

Original: For example, B&L achieves 4.69%-9.65% relativeerror in the artificial dataset, and 0.44%-0.79% relative error in the real-life dataset.