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

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 tackleoptimization problems containing parameters that are unknown at the time ofsolving.

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 satisfyingsimple conditions, we generalize previous work substantially by showing how acorresponding learning algorithm can be constructed directly and methodicallyfrom 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 byviewing 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 showsbetter 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 frameworktackles optimization problems with parameters that are unknown at solving time.

Original: Such uncertainty iscommon in daily life and industry.
Revised: Such uncertainty iscommon in daily life and industry.

Original: For example, retailers need to pick items to restock for maximizingproﬁt, yet consumer demand is a-priori unknown.
Revised: For example, retailers need to pick items to restock for maximizingprofit, 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 usingthe 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 measuresindependent 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 estimatedand 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, andgradient-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 objectiveand 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: Theycan 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 computethe (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] proposea 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 integralobjective 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: Mandyand 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 thestructure 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 tolearn 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 forproblems amenable to tabular dynamic programming (DP).

Original: We propose a novel exact method for problems solvable with a recursive algorithm (under somerestrictions), signiﬁcantly generalizing the work of Demirovi´c et al.
Revised: We propose a novel exact method for problems solvable with a recursive algorithm (under somerestrictions), significantly 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 aspecial 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 isimplemented 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 widelyapplicable technique, it is not universal in that many naturally recursively solvable problems are notknown 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 stillfundamentally 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 etal.

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

Original: Experiments on 3 benchmarks with artiﬁcial and real-life data against 9 other learning approachesconﬁrm the superior solution quality and scalability of our method.
Revised: Experiments on 3 benchmarks with artificial and real-life data against 9 other learning approachesconfirm 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 conqueralgorithm, extending the work of Demirovi´c et al.

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

Original: While the NeurIPSsubmission guideline does not require a comparison with their work, our benchmarks include also anexample problem (Multi-stage Scheduling) that can be handled readily by our framework but not theapproach of this concurrent work.
Revised: Whileboth Branch & Learn and [9] are exact methods for Predict+Optimize, there are problems amenableto Branch & Learn but not [9], and vice versa. The techniques used are also very different betweenthe two works. Section 6 compares the two pieces of work in more detail.

Original:  Background
Revised:  Background

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

Original: arg min x obj ( x ) s.t. C ( x ) , wherex 2 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 ) , 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 .

Original: Thus, x ⇤ is an optimal solutionand obj ( x ⇤ ) is the optimal value .
Revised: Thus, x ∗ is an optimal solutionand 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 the case where only theobjective 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 extendsthe problem P as follows:

Original: [Equation]
Revised: [Equation]

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

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

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

Original: Example 1.
Revised: Example 1.

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

Original: Theproblem is an instance of 0-1 knapsack.
Revised: Theproblem 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 onlysome features related to it given, such as proposal scores and the reputation of each applicant.

Original: In Predict+Optimize [5], the true parameters ✓ 2 R t for a Para-OP are unknown at solving time, andestimated parameters ˆ ✓ are used instead.
Revised: In Predict+Optimize [5], the true parameters θ ∈ R t for a Para-OP are unknown at solving time, andestimated 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: Theestimation will rely on a machine learning model trained over n observations of a training data set{ ( A 1 , θ 1 ) , . . .

Original: , ( A n , ✓ n ) } , where A i 2 R t ⇥ m is a feature matrix for ✓ i , so as to yield a predictionfunction f : R t ⇥ m ! R t for estimating parameters ˆ ✓ = f ( A ) .
Revised: , ( A n , θ n ) } , where A i ∈ R t × m is a feature matrix for θ i , so as to yield a predictionfunction 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 objectivedifference between the true optimal solution x ∗ ( θ ) and the estimated optimal solution x ∗ (ˆ θ ) underthe true parameters θ .

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

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

Original: [Equation]
Revised: [Equation]

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

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

Original: [7] choose the predictionfunction from the set of models F to attain the smallest average regret over the training data:
Revised: [7] choose the predictionfunction 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 thesolution structure of a Para-OP using (continuous) piecewise linear functions.

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

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

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

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

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

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

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

Original: For piecewise linear functions h and g , wedeﬁne pointwise addition as ( h + g )( r ) = h ( r ) + g ( r ) for all r 2 R .
Revised: For piecewise linear functions h and g , wedefine pointwise addition as ( h + g )( r ) = h ( r ) + g ( r ) for all r ∈ R .

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

Original: All ﬁve operations can be computed efﬁciently by iteratingover intervals of the operands [5].
Revised: All five operations can be computed efficiently by iteratingover 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 formf ( A ) =

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

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

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

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

Original: Construct constructs a
Revised: Construct constructs a

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

Original: I 0 .
Revised: I 0 .

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

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

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

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

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

Original: [Equation]
Revised: [Equation]

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

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

Original: =
Revised: =

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

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

Original: Constructsynthesizes the parameterized problem
Revised: Constructsynthesizes the parameterized problem

Original: [Equation]
Revised: [Equation]

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

Original: R for  .
Revised: R for γ .

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

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

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

Original: Associated with each interval I 2 I ( E i (  )) , a linear function maps  to the objective computed withthe estimated parameters a i  + b i , and the estimated optimal solution x ⇤ ( a i  + b i ) remains the samein each intervalI [4, 5].
Revised: 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: 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: [Equation]
Revised: L i [ I ] =

Original: where  is a function arbitrarily selecting a value from an interval I . The resulting function L i ispiecewise constant and represents the regret for different values of the free coefﬁcient.
Revised: Regret ( a i χ ( I ) + b i , θ i ) =

Original: If  / 2 I 0 , 
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: 1 Function ReSolve ( P, θ ) : if isBaseCase ( P ) then ( x ∗ ( θ ) , C ∗ ( θ )) ← BaseCase ( P, θ ) ; else

Original: T  Extract ( P, ✓ ) ;
Revised: T ← Extract ( P, θ ) ;

Original: PL  Branch ( P, ✓ , T ) ;
Revised: PL ← Branch ( P, θ, T ) ;

Original: RL  Map ( ReSolve , PL ) ; ( x ⇤ ( ✓ ) , C ⇤ ( ✓ ))
Revised: RL ← Map ( ReSolve , PL ) ; ( x ∗ ( θ ) , C ∗ ( θ ))

Original:  Reduce (  , RL ) ; return R 

Revised: ← Reduce ( ⊕ , RL ) ; return R

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

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

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

Original: PL
Revised: do

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

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

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

Original: Reduce (  , RL ) ; return R ; the  value of L i is set to a sufﬁciently large constant to indicate impracticability of the estimationˆ ✓ = a i  + b i .
Revised: The resulting function L i ispiecewise constant and represents the regret for different values of the free coefficient. If γ / ∈ I 0 ,the value of L i is set to a sufficiently large constant to indicate impracticability of the estimationˆ θ = a i γ + b i .

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

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

Original: In this paper, we signiﬁcantly generalize the 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 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.

Original: A majorobstacle to the generalization is that different prediction coefﬁcients  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 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.

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 coefﬁcient  .
Revised: 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 γ .

Original: The following sections describe these ideas in detail.
Revised: The following sections describe these ideas in detail.

Original:  Recursively Solvable Problems
Revised:  Recursively Solvable Problems

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

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

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

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

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

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

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

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

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

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

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 value C ⇤ and optimal decisions x ⇤ for P ( ✓ ) .It has several key components.i) isBaseCase determines if P
Revised: The ReSolve function accepts a recursively solvable Para-OP P along with known parameters θ ,and returns the optimal value C ∗ and optimal decisions x ∗ for P ( θ ) .

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

Original: Extract , using the current problem P and the current parameters ✓ , computes some information
Revised: Extract , using the current problem P and the current parameters θ , computes some information

Original: T from which the list of subproblems can be determined.
Revised: T from which the list of subproblems can be determined.

Original: iii) Branch , using only T , creates andreturns a list PL of subproblems, and further computes their corresponding parameters from both
Revised: iii) Branch , using only T , creates andreturns a list PL of subproblems, and further computes their corresponding parameters from both

Original: T and the current parameters ✓ .
Revised: T and the current parameters θ .

Original: iv)
Revised: iv)

Original: Each subproblem in the list PL is solved recursively, via Mapmapping Resolve to PL .
Revised: Each subproblem in the list PL is solved recursively, via Mapmapping 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 abinary operation ⊕ via Reduce .

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 theunknown parameters are + , − , max , min and multiplication with known constants, ii) there are noconditionals 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 projectfunding (0-1 knapsack) problem in Example 1.

Original: ReSolve_KS takes input ( p, c, n, W, S ) where n isthe number of remaining projects to consider, W is the remaining funding available, and S is the setof selected projects so far.
Revised: ReSolve_KS takes input ( p, c, n, W, S ) where n is 9 Function i ∈ S ; else the number of remaining projects to consider, W is the remaining funding available, and S is the setof 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 ] W else 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 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.

Original: As mentioned, the ReSolve template in Algorithm 2 also captures iterative algorithms as recursionwith a single branch.
Revised: As mentioned, the ReSolve template in Algorithm 2 also captures iterative algorithms as recursionwith a single branch.

Revised: Limitations of requirements on the recursive algorithm Before Example 2, we specified requirements on recursive algorithms that this paper considers.

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

Revised: Perhaps the most restrictive requirements arethe ones on the arithmetic operations we allow in the ReSolve algorithm.

Revised: Here, using a couple ofexamples, we illustrate some of the limits of our framework.

Original: The Branch & Learn Framework
Revised: 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 ). Computing the product of rewards involves multiplying (instead ofadding) unknown parameters, which our framework cannot handle directly. On the other hand, theproblem is equivalent to maximizing the sum of the logarithm of the two rewards. 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: 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: 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.

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 asthe 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),
Revised: Recall from Section 2 that, in the context of the coordinate descent algorithm (Algorithm 1),

Original: 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 coefﬁcientcoordinate  , and ii) the domain I 0 of  , also constructed from ( A, ✓ ) (for example, to ensure basicproperties of parameters such as non-negativity).
Revised: 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).

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 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.

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 ReSolvealgorithm, and we explain each component of ReLearn here.

Original: ReSolve in Algorithm 2 has component functions isBaseCase , BaseCaseL , ExtractL ,
Revised: ReSolve in Algorithm 2 has component functions isBaseCase , BaseCaseL , ExtractL ,

Original: BranchL , Map and Reduce .
Revised: 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) involveany parameters, they are the same as the ones in ReSolve .

Original: As for BaseCaseL , ExtractL and
Revised: As for BaseCaseL , ExtractL and

Original: BranchL , they can be simply obtained from ReSolve by replacing all numerical operations on theparameters with their generalizations to piecewise linear functions.
Revised: BranchL , they can be simply obtained from ReSolve by replacing all numerical operations on theparameters with their generalizations to piecewise linear functions.

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

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

Original: Otherwise, it performs the recursion as follows: i)
Revised: Otherwise, it performs the recursion as follows: i)

Original: 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 coefﬁcient  .
Revised: 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 γ .

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

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

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

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

Original: ii)
Revised: ii)

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

Original: Note that, since we map ReLearn instead of
Revised: Note that, since we map ReLearn instead of

Original: ReSolve to PL , even within the current interval I , the ﬁnal estimated objective will generally befurther subdivided into smaller pieces.
Revised: ReSolve to PL , even within the current interval I , the final estimated objective will generally befurther 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 ofjust 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 thefurther 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 Pi
Revised: The adapted ReLearn_KS in Algorithm 3 solves the parameterized 0-1 knapsackproblem with the inputs of the parameterized problem P

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

Original: I 0 .
Revised: I 0 .

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

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 signiﬁcant 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 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.

Original: For this reason, we do not embark on suchformalization in this paper.
Revised: For this reason, we do not embark on suchformalization 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 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.

Original:  Case Studies
Revised:  Case Studies

Original: This section gives several case studies of applying the framework.
Revised: This section gives several case studies of applying the framework.

Original: We ﬁrst demonstrate, using theexample of shortest path problem (SPP), how our framework can recover the DP based method by
Revised: We first demonstrate, using theexample of shortest path problem (SPP), how our framework can recover the DP based method by

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

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

Original: To demonstrate the full recursiongenerality that our framework can handle, we use it on the recursive tree-search algorithm for the NPhard problem of minimum cost vertex cover (MCVC).
Revised: To demonstrate the full recursiongenerality that our framework can handle, we use it on the recursive tree-search algorithm for the NPhard 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 otherprior 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 the detailedpseudocodes are given in Appendix A.

Original: Shortest Path Tabular DP can be viewed as an iterative algorithm, computing the subproblem tablerow by row.
Revised: Shortest Path Tabular DP can be viewed as an iterative algorithm, computing the subproblem tablerow by row.

Original: In our framework, the Branch operation in ReSolve generates a single subproblem
Revised: In our framework, the Branch operation in ReSolve generates a single subproblem

Original: P 0 , which furthermore does not depend on the unknown parameters (only the parameters to P 0depend on the unknown parameters to the current problem).
Revised: P ′ , which furthermore does not depend on the unknown parameters (only the parameters to P ′depend on the unknown parameters to the current problem).

Original: With this perspective, the framework of
Revised: With this perspective, the framework of

Original: Demirovi´c et al.
Revised: 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 withpotentially negative weights.

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

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

Original: The inputs of ReSolve_SPP are( G c , D, s, t, N ) , where G c 2 R | V | ⇥ | V | is a matrix with entry ( G c ) uv equal to the cost along 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 ∈ 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.

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

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

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

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

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

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

Original: In the parameterizedproblem P  , parameterized by the free coefﬁcient  in the coordinate descent, the edge costs arenon-negative parameters represented by linear functions of  .
Revised: In the parameterizedproblem P γ , parameterized by the free coefficient γ in the coordinate descent, the edge costs arenon-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 pathunder 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 iterativelysolvable problem: MCFP in a directed graph, where at most one edge exists between any two vertices.

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

Original: Given input
Revised: Given input

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

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

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

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

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

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

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

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

Original: The variable F 2 R | V | ⇥ | V | is a matrix representing theﬂow sent along each edge so far.
Revised: The variable F ∈ R | V |×| V | ≥is a matrix representing theflow 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 ﬂows in F ,i.e. R = 
Revised: 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 .

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

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

Original: T .
Revised: T .

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

Original: The ﬂow is also added to F .
Revised: The flow 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 iscalled recursively on these new G p and F as well as the original G c , s and t .

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

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

Original: ExtractL_MCFP adapts from the Bellman-Ford ReLearn_SPP in the previous case study, 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, whichcomputes a piecewise data structure T γ mapping intervals (for γ ) to different shortest paths (inaddition to just the path lengths).

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

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

Original: ReLearn_MCFP is recursively called on P 0  , until the base caseis reached.
Revised: ReLearn_MCFP is recursively called on P ′ γ , until the base caseis 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 toapply our framework to a (non-degenerate) recursive algorithm (with multiple branches).

Original: Given agraph G =
Revised: Given agraph G =

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

Original: Thecosts are unknown parameters.
Revised: Thecosts 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 onan edge needs to be picked.

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

Original: Consider, for example, the graph being a road network with edge values being trafﬁc ﬂow, and 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 traffic flow, and wewish 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 asbefore, n is the number of levels of (binary) recursion remaining and chosen is the current listof 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 inﬁnity otherwise.
Revised: 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.

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 options.

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

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

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

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

Original: The goal is to ﬁnd an ordering for processing itemsthat minimizes the total elapsed time.
Revised: The goal is to find an ordering for processing itemsthat 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 individualitem 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 methodscannot 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 asthe 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 aproblem formulation with an objective that is bilinear in the unknown parameters and the decisionvariables (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 handlesthis 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 fordetails of ReSolve_MSS and ReLearn_MSS as well as their pseudocode.  Comparing Branch & Learn with Latest Work

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

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

Original: Experimental Evaluation
Revised: Both also use coordinatedescent as the high-level optimization routine. 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. In terms of the applicable problems, Branch & Learn applies to all optimization problems amenable toan optimization algorithm fitting the ReSolve template in Section 3. 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: There are problems amenable to Branch & Learn but not [9], and vice versa.

Revised: Here we can give someintuition about when each method is applicable.

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

Revised: 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: If, additionally, the objective function isbilinear as in the assumption of [9], then Branch & Learn would be able to handle such a problem.

Revised: Inthis sense, an optimization problem with a finite solution set that is solvable by [9] would also besolvable by Branch & Learn.

Revised: 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: On the other hand, if the solution space is continuous, Branch & Learn might not be able to handlesuch an optimization problem.

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 regrethas a finite representation (say, as a piecewise linear function).

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

Revised: By contrast, [9] nevercomputes the entire regret function explicitly.

Revised: Instead, it just queries the regret function and computesits values, and then performs numerical optimization on the function (which is convex when theobjective is bilinear).

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

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

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

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),classiﬁcation and regression tree (CART) and random forest (RF) [8], 3 approximation methodsincluding smart predict then optimize (SPO) [6], quadratic programming task loss (QPTL) 
Revised: 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]

Original: [17],and interior point based approach (IntOpt) [12], and 2 exact methods, namely SPO tree and SPOforest [7].
Revised: [Table] and interior point based approach (IntOpt) [12], and 2 exact methods, namely SPO tree and SPOforest [7].

Original: We experiment on three optimization problems: MCFP, MCVC and MSS—problems that [Table] [Table] the previous DP-based method cannot handle, and use both artiﬁcial and real-life data on real-lifegraphs.
Revised: 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.

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], with 24 vertices and 43 edges, and GÉANT [10], with40 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

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

Original: In MCVC, the costs areunknown.
Revised: In MCVC, the costs areunknown.

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

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

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

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

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

Original: Given that we are unable to ﬁnd datasets speciﬁcallyfor the MCFP, MCVC and MSS problems, we follow the experimental approach of Demirovicet al.
Revised: Given that we are unable to find datasets specificallyfor the MCFP, MCVC and MSS problems, we follow the experimental approach of Demirovi´cet 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) asnumerical values required for our experiment instances.

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

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
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

Original: SPO Forest.
Revised: 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 eachmethod 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 demonstratethe performance.

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

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

Original: On the artiﬁcial dataset, B&L,
Revised: On the artificial dataset, B&L,

Original: LR, k -NN, RF, IntOpt, and SPO Forest achieve similar performance on both of the two graphs, while
Revised: 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 signiﬁcant advantages.
Revised: With the real-lifedataset, B&L shows the most significant 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 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.

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

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

Original: This is consistent with how the artiﬁcial dataset is purposefully designed to be highly non-linear (see
Revised: This is consistent with how the artificial dataset is purposefully designed to be highly non-linear (see

Original: Appendix B), and thus harder to learn.
Revised: Appendix B), and thus harder [Table]

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

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

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

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

Original: [Table] 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 amongdifferent methods are larger in the real-life dataset, and the advantages of B&L are more evident.

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

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

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

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

Original: Note that linearprogramming based methods including SPO, QPTL and IntOpt are not applicable to this problem asmentioned in Section 5.
Revised: Note that linearprogramming based methods including SPO, QPTL and IntOpt are not applicable to this problem asmentioned 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 ofjobs 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 withthe 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 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.

Original: On the artiﬁcialdataset, all algorithms perform essentially the same, achieving 4.69%-9.65% relative error.
Revised: On the artificialdataset, 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 methodssacriﬁce the accuracy of the learned model, which is the motivation for the line of work on Predict+Optimize.
Revised: Scalability/Runtime Learning using regression or approximate methods is fast, but these methodssacrifice 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: Althoughexact methods achieve lower regret, their runtime scalability can be an issue since their learningprocess 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 theaverage 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 atleast 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 signiﬁcant training time to explore all thepossible predictions.
Revised: 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.

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

Original:  Summary
Revised:  Summary

Original: Given a ReSolve function for a recursively or iteratively solvable problem, we propose a 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 systematicapproach to synthesize a ReLearn function for learning with the regret loss, by replacing operatorsin ReSolve with their piecewise linear counterparts.

Original: Our proposal is methodical and straightforwardto implement.
Revised: Our proposal is methodical and straightforwardto 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.
Revised: Most importantly, B&L empiricallyachieves the lowest regrets against classical machine learning and contemporary Predict+Optimizealgorithms with runtime comparable with the latter.

Original: Checklist
Revised: Checklist

Original: The checklist follows the references.
Revised: The checklist follows the references.

Original: Please read the checklist guidelines carefully for information onhow to answer these questions.
Revised: 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] .
Revised: For each question, change the default [TODO] to [Yes] , [No] , or[N/A] .

Original: You are strongly encouraged to include a justiﬁcation to your answer , either by referencingthe appropriate section of your paper or providing a brief inline description.
Revised: 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:
Revised: For example:

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

Original: [Yes]See Section ?? .•
Revised: [Yes]

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

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

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

Original: [N/A]
Revised: [N/A]

Original: Please do not modify the questions and only use the provided macros for your answers.
Revised: Please do not modify the questions and only use the provided macros for your answers.

Original: Note that the
Revised: Note that the

Original: Checklist section does not count towards the page limit.
Revised: Checklist section does not count towards the page limit.

Original: In your paper, please delete this instructionsblock and only keep the Checklist section heading above along with the questions/answers below.
Revised: 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...
Revised: For all authors...

Original: (a) Do the main claims made in the abstract and introduction accurately reﬂect the paper’scontributions and scope?
Revised: (a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope?

Original: [Yes](b) Did you describe the limitations of your work?
Revised: [Yes] (b) Did you describe the limitations of your work?

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

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

Original: [N/A](d)
Revised: [N/A]

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

Original: [Yes]2.
Revised: [Yes]2.

Original: If you are including theoretical results...
Revised: If you are including theoretical results...

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

Original: [N/A](b)
Revised: [N/A]

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

Original: [N/A]3.
Revised: [N/A]

Original: If you ran experiments...
Revised: 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)?
Revised: (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 supplemental material(b)
Revised: [Yes] See supplemen- tal material

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

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

Original: [Yes] See Section
Revised: [Yes] See Section

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

Original: ments multiple times)?
Revised: ments multiple times)?

Original: [Yes] See Section
Revised: [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)?
Revised: (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
Revised: [Yes] See Section

Original: If you are using existing assets (e g., code, data, models) or curating/releasing new assets...
Revised: 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?
Revised: (a) If your work uses existing assets, did you cite the creators?

Original: [Yes] See Section
Revised: [Yes] See Section

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

Original: [N/A]
Revised: [N/A]

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

Original: [Yes]
Revised: [Yes]

Original: We include code and data in supplemental materials.
Revised: 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
Revised: (d) Did you discuss whether and how consent was obtained from people whose data you’re

Original: using/curating?
Revised: using/curating?

Original: [N/A]
Revised: [N/A]

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

Original: information or offensive content?
Revised: information or offensive content?

Original: [N/A]
Revised: [N/A]

Original: If you used crowdsourcing or conducted research with human subjects...
Revised: 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
Revised: (a) Did you include the full text of instructions given to participants and screenshots, if

Original: applicable?
Revised: applicable?

Original: [N/A]
Revised: [N/A]

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

Original: Board (IRB) approvals, if applicable?
Revised: Board (IRB) approvals, if applicable?

Original: [N/A]
Revised: [N/A]

Original: (c) Did you include the estimated hourly wage paid to participants and the total amount
Revised: (c) Did you include the estimated hourly wage paid to participants and the total amount

Original: spent on participant compensation?
Revised: spent on participant compensation?

Original: [N/A]
Revised: [N/A]

Revised: A Pseudocode for Case Studies

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

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

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

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

Revised: Algorithm

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

Revised: R ← D [ t ] ; else

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

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

Revised: D ′

Revised: [ v ] =

Revised: min

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

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

Revised: R [ I 0 ] ← D γ [ t ] ; else

Revised: D ′ γ ← ExtractL_SPP ( G cγ , D γ , I 0 ) ; [ P ′ ] ← BranchL_SPP ( G cγ , D ′ γ , s, t, N − 1) ;

Revised: R [ I 0 ] ← ReLearn

Revised: Flow

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

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

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

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

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

Revised: 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 ′ )

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

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

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

Revised: ; 10 Function

Revised: : for

Revised: V do for do each do

Revised: return

Revised: ; 19 Function

Revised: _MCFP p

Revised: G cγ

Revised: F γ [ I ]

Revised: T γ [ I ]) :

Revised: ; for

Revised: I do

Revised: ; for do block _ flow ;

Revised: [ I

Revised: [ I

Revised: ; return ( G p ′ , G cγ , F ′ γ

Revised: [ 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 = 
+}

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

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

Revised: R ← R + c

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

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

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

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

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

Revised: 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 = 
+}

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

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

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

Revised: 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 ]) ;

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

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

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

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

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

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

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

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

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

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

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

Revised: Given this processing,

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

Revised: ReSolve_MSS is called recursively.

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

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

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

Revised: ReLearn_MSS isrecursively called on P ′ γ , until the base case is reached.

Revised: 1 Function ReSolve_MSS ( n, schedule, remainingItems, timeReq ) : if n

Revised: then

Revised: M 1 Time ← 0 ;

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

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

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

Revised: M timeReq [ i ][ do

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

Revised: γ do

Revised: M timeReq γ [ i ]

Revised: M 2 Time

Revised: M 2 Time timeReq γ i ]

Revised: M

Revised: ← M 1 Time timeReq γ

Revised: i

Revised: R [ I

Revised: ] ← M

Revised: ; else do

Revised: BranchL

Revised: return remainingItems

Revised: I

Revised: : minProTime do i ] do

Revised: B Experimental Setting

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

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

Revised: [Table]

Revised: [Table]

Revised: (e.g. length 1).

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

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

Revised: The Generation of the Artificial Dataset

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Revised: C Additional Results: Multi-stage Scheduling

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

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

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

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

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

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

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

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