MIRACLE: Model-free Imitation and Reinforcement Learning for Adaptive Cut-Selection
Authors: Arjun M.
Rijul Tandon
Agam Gupta
HARIPRASAD KODAMANA
Manojkumar Ramteke
Venue: ICLR 2026 Poster (2026)
Keywords: Model-Based Reinforcement Learning
Adversarial Reward Learning
Proximal Policy Optimization
Mixed-Integer Programming
Combinatorial Optimization
Primary area: reinforcement learning
TL;DR: We propose a framework that reduces memory consumption of Mixed-Integer Programming solver using Reinforcement Learning and Imitation Learning

Abstract: Mixed-Integer Programming (MIP) solvers rely heavily on cutting planes to tighten LP relaxations, but traditional approaches generate thousands of cuts that consume gigabytes of memory while providing minimal benefit. We present an intelligent cut selection framework that achieves a 98.1\% reduction in memory usage while maintaining competitive solving with an objective gap of approximately 0.08\%. Within this RL framework, we use Proximal Policy Optimization (PPO) to learn a behavioral model that imitates the expert solver’s decisions. The adversarially imitated behavioral model drives an agent comprising these key innovations: (i) a cut-selection policy trained via curriculum learning; and (ii) adaptive inference that dynamically adjusts computational budgets. Through comprehensive evaluation across SetCover and diverse MIPLIB problems, we demonstrate consistent speedups (3.78$\times$ average on MIPLIB) and achieve a 100\% success rate on instances where traditional SCIP fails 47-53\% of the time. Our method also reduces peak memory consumption from 3.03GB to 46 MB, enabling optimization in previously inaccessible and other resource-constrained environments where traditional solvers face fundamental limitations.

Published as a conference paper at ICLR 2026
MIRACLE: MODEL-FREE IMITATION AND REINFORCE- MENT LEARNING FOR ADAPTIVE CUT-SELECTION
Arjun M. Rijul Tandon'
Manojkumar Ramteke 1.2 Agam Gupta?
Hariprasad Kodamana" 1,2,3
1 DDepartment of Chemical Engieering 8 ANSK School of IT
Yardi School of Artificial Intelligence *Department of Management Studies
Indian Institute of Technology Delhi, New Delhi, 110016, India
(chz2381946, ramteke?, agamê, kodamana .ttpaaannaaddddd...... wiidd.ac.......
ABSTRACT
Mixed-Integer Programming (MIP) solvers rely heavily on cutting planes to tighten LP relaxations, but traditional approaches generate thousands of cuts that consume gigabytes of memory while providing minimal benefit. We present an intelligent cut selection framework that achieves 98.1 1% reduction memory usage while maintaining competitive solving with objective gap of approximately 0.08%. Within this RL framework, we use Proximal Policy Optimization (PPO) to learn behavioral model that imitates the expert solver's decisions. The adversarially imitated behavioral model drives an agent comprising these key innovations: (i) cut-selection policy trained via curriculum learning; and (ii) adaptive inference that dynamically adjusts computational budgets. Through comprehensive evalu- ation across SetCover and diverse MIPLIB problems, we demonstrate consistent speedups (3.78x x average on MIPLIB) and achieve 100% success rate on instances where traditional SCIP fails 47-53% of the time. Our method also reduces peak memory consumption from 3.03GB 46 MB, enabling optimization in previously inaccessible and other resource-constrainet environments where traditional solvers face fundamental limitations.
INTRODUCTION AND RELATED WORK
Combinatorial optimization lies at the heart of numerous real-world applications, from production planning (Pochet & Wolsey 2006) and scheduling (Cao al. 2022) network design (Nieman al. 2024| Wolsey| (2020). These problems often manifest as Integer Programs (IPs), which remain notoriously difficult to solve to optimality due to their NP-hard nature (Bixby et al. (004).. State-of-
the-art solvers, such Solving Constraint Integer Programs (SCIP) (Gamrath al. (020), rely on
the branch-and-cut algorithm, which iteratively tightens a Linear Programming (LP) relaxation of the problem by adding cutting planes. However, the efficacy of this process critically constrained by fundamental bottleneck: cut management. For a typical industrial problem, a modern solver can generate over 100,000 candidate cuts, but only tiny fraction (1-2%) of these cuts meaningfully improve the objective bound. This gross inefficiency makes large-scale optimization intractable in memory-constrainee environments where resource costs are paramount.
Machine learning for combinatorial optimization has seen significant interest, particularly in en- hancing MIP solver components. Early works focused on imitation learning for variable branching (Khalil et al. 2017 Gasse et al.] (2019). More recently, attention has shifted to cut selection. (Tang ctt al. 2020) introduced RL for cutting plane selection, though their approach focused primarily on immediate reward maximization. Paulus et al. (2022) proposed using imitation learning to mimic strong- branchinnn decisions for cut selection. Most closely related to our work (Wang et al. 2024), which utilizes hierarchical sequence model to select cuts. However, these approaches generally treat the MIP solver as a black box, optimizing solve time directly, often overlooking memory overhead. In contrast, MIRACLE explicitly models the memory perforaperformmacc trade-off. Unlike (Wang et al.

---

Published as a conference paper at ICLR 2026
2024) and Paulus et al. (2022). which often require heavy architectures or look-ahead rollouts, our approach utilizes a lightweight, oudget-constrained policy optimized via PPO and GAIL to achieve an order-of-men --ngiiudde memory reduction while maintaining solution reliability in resource-constraine environments.
While these methods have demonstrated performance gains, they are built paradigm that suffers from three fundamental limitations:
1.
Existing approaches treat the MIP solver as a black box. They learn copy expert decisions interact in a model-free fashion, but they fail to model the underlying dynamics of the optimization process (Deza Khalil 2023; Zhang et al. 2024). They do not learn how adding cut will change the subsequent state of the LP relaxation, process instead handled by an external, non-differentiable solver (Huang et al. 2022).
The Black-Box Fallacy:
2. Myopic Planning:
direct consequence of the black-box approach is that learned policies are restricted to myopic decisions. Lacking a model of the environment, they cannot plan ahead or reason about the long-term consequences of their actions, preventing the discovery of more sophisticated, non-local strategies.
3. Resource Inefficiency as an Afterthought: Prior work has predominantly focused on improving solution time, largely ignoring memory overhead as critical performance metric. This makes them ill-suited for the very resource-constrained scenarios where learned, efficient heuristics are most desperately needed.
This work addresses critical gap: Can we learn intelligent cut selection policies that achieve significant memory reductions while maintaining competitive solving performance? Our approach reframes cut selection as an RL problem where we learn a behavioral model of expert cut selection rather than attempting to model the complex LP dynamics directly.
1.1 KEY CONTRIBUTIONS
Our work makes the following contributions:
Memory-Fine Optimization Paradigm: We demonstrate that intelligent cut selection can achieve significant memory reductions (97.7-98. 1 on SetCover benchmarks, 1-.1. 1% diverse MIPLIB problems) while maintaining or improving solution quality.
Robust Behavioral Modeling Framework: Our PPO-based approach learns behavioral model of expert cut selean average reduction of 86.3%) and reliability improvements 100% success rate compared to 53% arning and adaptive inference, we eliminate manual parameter tuning and provide a deployment-ready system with inference complexity independent of problem size.
Comprehensive Empirical Validation: We provide a systematic evaluation across 300 instances spanning SetCover training problems and diverse MIPLIB test cases (Huang et al.. 2024). Our analysis includes statistical significance testing, confidence intervals, and effect size measurements, demonstrating both memory efficiency (an average reduction of 86.3% and reliability improvements (100% vs. 53% success rate on challenging instances).
Ablation Studies and Robustness: We demonstrate that our framework's 's performance remains stable across different hyperparameter configurations (cut budgets 10-50, iteration limits 1-10, various early stopping criteria). indicating reliable real-world deployment characteristics essential for industrial adoption.
To this extent, our approach reframes cut selection through the lens of RL. Rather than attempting to model the prohibitively complex LP transition function. we learn to imitate and ultimately improve upon SCIP's implicit selection policy. SCIP's cut-selection module serves as the expert policy because it encapsulates decades of solver engineering and remains the strongest publicly available heuristic baseline. This achieved by training neural policy using Proximal Policy Optimization (PPO) (Schulman et al.) (017). guided by dense reward signals derived from Generative Adversarial Imitation Learning (GAIL) (Ho & Ermon 2016 Finn et al. 2016). PPO is particularly well-suited for this task due to its remarkable stability and the reliable balance it strikes between policy improvement and destructive, overly large updates - a critical feature for navigating the variance decision space of cut selection. While our framework could accommodate other advanced policy gradient
2

---

Published as a conference paper at ICLR 2026
methods, PPO provides a strong and sample-efficient foundation. Furthermore, behavioral modeling using the GAIL approach enables us to capture the implicit knowledge embedded in decades of solver development, while optimizing explicitly for memory efficiency goal that traditional heuristics cannot directly target.
2 BACKGROUND AND PROBLEM FORMULATION
This section establishes the necessary mathematical foundations and formally defines the selection problem addressed in this work.
Definition 2.1 (Integer Programming). An Integer Programming (IP) problem seeks to optimize a linear objective over sel of integer variables, subject to linear constraints, formulated as:
min T x s.t. Ar Sb, x EE
where c E R" is the objective vector, and the feasible region is defined by the constraint matrix E mx and vector 1 m
A standard solution approach to IP, branch-and-cut, begins by solving the continuous LP relaxation (k)
of the problem. If the solution JiP at iteration k is fractional, set of linear inequalities known as cutting planes cuts (a"x S B, where E RR" and RR generated. A subset of these cuts is selected and added to the formulation to form a tighter LP relaxation, which is then re-solved. This iterative process continues until an integer-optimal solution is found. More details be found in the Appendix C Selecting subset of cuts can be sequential decision maaiiinnnmmiing problem and thus can be modelled Markov Decision Process (MDP). which is defined below:
Definition 2.2 (Markov Decision Processes). An MDP defined by the tuple M (S, 7). where S is the state space, A is the action space, P((s+1 ([sk4i|sk, ax) models the transition dynamics of the state s and action a iteration k, R(sk, 01.) is the reward function, and 7 E [0, 1] is a discount factor, with appropriate dimensions.
We frame the cut selection task as specific MDP, with components carefully designed to address the unique challenges of MIP optimization. This achieved using state space S where each state St is comprehensive feature vector capturing the solver's 's context. The agent's 's policy operates an action space A, defined as the set of binary decisions over candidate cuts, subject to memory-enforeing budget B. Critically, to overcome the challenge of sparse and delayed feedback, we employ learned reward function R.
Problem 2.3 MMeorry-ffficiee Cut Selection). The central problem is to learn a cut selection policy : S A that, each iteration k of the branch-ante aaanchh--nd-utt process, selects action og A (a subset of candidate cuts) based on the current solver state sk and satisfies the two main objectives:
1. Memory Efficiency: Minimize the memory consumed by reducing the number of cuts being added to the LP relaxation, within appropriate budget B. This is measured in Bytes.
2. Solver performance: Maximize the overall solving performance. This is defined as [ojjSCTP objMTRACLEE S where objo. is the objective value obtained.
The detailed architecture of our policy, the implementation of this adversarial reward system, and the strategies used to ensure robust training are claborated upon in the following section.
3 MIRACLE: INTELLIGENT AND MEMORY EFFICIENT CUT SELECTION
Our framework, MIRACLE, trains policy to select minimal yet high-impact subset of cuts, balancing objective improvement with memory and computational costs. The core of our approach is fast, lightweight policy trained via PPO, guided by dense rewards from a sophisticated reward learner based on GAIL. This is complemented by curriculum learning and an adaptive inference system ensure robust, real-world performance.
3

---

Published as a conference paper at ICLR 2026
Figure MIRACLE Frame- work. At each step (k), the SCIP Environment, generates state (5k) and candidate cuts (C&)). This information is processed by our trained MIRACLE Agent (TO), which selects a small subset of cuts (ax) and applies them back into the environment. The LPP is re-solved until final solution is reached. The agent's 's policy is learned offline via PPO, guided by dense reward signal from a GAIL Discriminator trained on expert SCIP trajectories.
Iterative Solving Process
Oftine Training
GAIL. Dis- criminator De
Learned Reward TOAL
MIRACLE Agent
Expert Trajectories (from SCIP)
(rre with PPO)
Selects
En- vironment
Generates
Selected Cuts dz
Candidate Cuts Co
Solution
Apply Cuts & Re-Solve IP
Traditional MIP solvers generate thousands of candidate cuts during the optimization process, consuming substantial memory while providing diminishing returns. We formulate the task of intelligent cut selection as an MDP, where our agent learns to identify a critical subset of cuts to maximize performance while improving memory efficiency. We conceptualize the underlying MIP solver in our case, SCIP- as the environment. At each iteration & in the branch-and-cut algorithm, the SCIP environment generates a pool of candidate cuts Cs based on its highly-tuned internal procedures and emits corresponding state s that captures the current state of the optimization. Our agent, MIRACLE, processes this information and performs an action ag, which consists of selecting a small, budgeted subset of cuts from Cg. The selected cuts added the LP formulation, which is then re-solved. An overview of the framework is presented in Figure This is formally defined below:
Problem 3.1 (Intelligent Cut Selection as an MDP). We define the problem of intelligent cut selection as an MDP framework, where an agent takes an action ag, which a binary selection vector over the subset of candidate cuts, Ck= = {cI, ......... 9ca) (c,,c,,..,,CCa)) defined as
(1) (2)
ak (Cal)). where 0% e0,
0% (a O
(2)
based on budget constraint compared to an expert action.
Σ
B. and maximizes its cumulative reward R(sk, ax) when i= 0g <
|cal (6)
To solve Problem 3.1
our framework, MIRACLE, employs PPO to train the policy Tg. We address the critical challenge of sparse rewards by learning the reward function R using GAIL. from expert data, which here comprises the SCIP solver steps that includes: (LP relaxation solving, fractional variable identification, rounding cut generation, cutting plane selection, constraint addition, LP re-optimization, objective improvement measurement, and iterative refinement), and we ensure robust, real-world performance through a curriculum learning strategy and an adaptive inference system.
3.1 ADVERSARIAL REWARD LEARNING FOR DENSE FEEDBACK
In cut selection, the true reward signal is only observable after the problem is completely solved. Hence, in this context, traditional reward engineering approaches may fail because: (i) immediate feedback (e.g.. bound improvement) is myopic and misleading, (ii) optimal reasoming about complex interactions between cuts, and (iii) memory efficiency objectives cannot be easily encoded in handcrafted reward functions. Therefore, learning rewards from expert behavior is essential to capture the implicit knowledge embedded in decades of solver development. Instead of handcrafting reward R (sk, ax), we train discriminator network to distinguish between the behaviour of an expert (which is SCIP here) and our learning agent.
selection requires
The discriminator, D& S
[0, 1], which parameterized as a MLP:
(sk, ax) = p((()) f(L-1) o .... ...o ( f (sk.
where I is a layer function such that (() for I E (l,..., L 1) is an affine transformation followed by ReL.U activation and f(L), is a linear output layer that produces the logits. This is trained via
4

---

Published as a conference paper at ICLR 2026
standard adversarial binary cross-entropy objective to distinguish expert trajectories TE from agent's ' policy Te. The expert policy Fg is derived from SCIP's systematic cutting plane methodology, formally defined as:
TE (a(() = SCIPeuts($H) = T8 o T7 .... (1(s))
where (71, (7,,T,,... .2,....777 Ts} represents the sequential tuple of operations: (LP relaxation solving, frac- tional variable identification, rounding cut generation, cutting plane selection, constraint addition, LP re-optimization, objective improvement measurement, and iterative refinement). This expert data is collected by running the default SCIP solver on a diverse set of training instances and recording the state-action decisions that emerge from this systematic autting-plane process. Our agent's 's policy is paramcterized as a neural network that learns to approximate the expert's 's cutting decisions:
(5) where f() for 1 E {I...., 1} is an affine transformation followed by ReLU activation, and f(L) is a linear output layer that produces the raw logits. Our agent's policy acts as the generator in this adversarial setup, producing its own trajectories by interacting with the SCIP environment and learning to mimic the expert's 's cutting decisions. The discriminator then trained distinguish these two sources of data:
TT (ax (8x) = so softmaz(fth of (((- o...o ....o (()
min (E(sL.)))<TEl log (sk, ax)] + B(s,,a))~=,l- log(1 (s ax)))) *
(6)
The rationale for this adversarial setup is grounded in the theory of generative adversarial networks. The optimal discriminator D* a) for this objective converges to (Goodfellow et al. 2014):
[s as))
D (sk, ax) (E ax) + To To(sk, as)
(7)
where (sR (g) and (5k 0g) represent the state-action occupancy measures of the expert and the agent, respectively. This means the discriminator learns to model the ratio of how likely an action come from the expert versus the agent. The learned reward function is then formally defined as:
R(sk, ax) R raAn a) = - log(1 - (s,
(8)
providing dense feedback that guides the policy toward expert-like behavior while allowing for improvement beyond expert performance. By doing so, the agent is encouraged to maximize the log- probability of its actions being classified as "expert." An action that perfectly fools the discriminator (Du(s, a) + 1) will yield a very high reward, while an action that is clearly (Dv(s,a) a) will yield low reward.
3.2 PPO-BASED POLICY LEARNING WITH EXPERT GUIDANCE
We train our neural policy, Tp, using PPO, a robust actor-critic method well-suited for the high- variance decision space of cut selection. The policy is implemented using an actor-critic architecture, with parameters 0 and ø. The actor learns the cut selection policy, and the critic estimates state values to guide the actor's learning. The actor, T 8&), computes a selection probability for each candidate cut e; based on its feature vector, Te;-- The final probability is produced by applying sigmoid function, a (.), to a raw score (logit) generated by an MLP:
(L-1) o...o (1)) (Zee 8k) Pl (6) =1(8k)= = (155 114
where each hidden layer (11) for 1 E [1, - 1} is an affine transformation followed by a ReLU acti- vation, and the final layer f(()) is a linear output producing the logit. Concurrently, the critic, (s(),. which estimates the state value, is also implemented as MLP that takes the state representation 8k
as input and outputs a single scalar value:
(L) Vo(sk) = g g0
(L-1) o...o gg((s)
(10)
(L) where the hidden layer 96 to g( (4-11) uses a ReLU activation and the final layer g is a linear output. In our implementation, the critic shares its input feature-extraction layers with the actor to improve learning efficiency.
5

---

Published as a conference paper at ICLR 2026
The training process is driven by the dense reward signal provided by our GAIL discriminator. As established in Section 3.1 the reward at each step l is given by rg TGAIL d+). With this signal, define the full PPO training objective. First, compute the advantage function using Generalized Advantage Estimation (GAE) (Schulman et al. 2015), which uses the critic's value estimates reduce variance:
ACAE ( 6K+1, where = Tk+t + (Vo(#k+++1 (o(sx+1)
(11)
Here, the value function (s(s) estimated by the critic network, and the rewards r14t are provided directly by our GAIL discriminator. The parameters of the actor, 0, are then updated by maximizing the PPO clipped surrogate objective:
CLIP (0) = Rs min (p=(0)
1)
(12)
where (0) xo(ayls)) is the probability ratio between the new and old policies. The critic's Te (as [su]
parameters, Ø, are trained concurrently by minimizing a standard mean-squared error loss on the state values. This formulation correctly uses the adversarially learned reward the primary signal for computing advantages, which in turn drive the PPO policy updates.
3.3 CURRICULUM LEARNING FOR ROBUST TRAINING
Training an RL agent directly on a diverse and challenging set of MIP instances inefficient and often leads to unstable convergence. To overcome this, employ a structured, four-phase curriculum learning strategy that guides the agent from foundational knowledge to sophisticated, general-purposs strategies. The curriculum begins with Foundation Phase on simple instances (200-500 constraints), where the agent learns to identify basic, high-utility cut patterns in low-noise environment. Having established this base policy, it then progresses through Scaling and Mastery Phases, where it exposed to progressively harder problems (up to 2000 constraints). This forces the agent to develop more complex, non-m non-myopic strategies that account for long-term consequences. The final and critical Integration Phase fine-tunes the agent a mixed-difficulty distribution, ensuring robust generalization across the entire problem spectrum.
3.4 ADAPTIVE INFERENCE
At deployment, MIRACLE leverages an adaptive inference system. lightweight, pre-trained classifier first analyzes the static features of new MIP instance to categorize its difficulty (EASY, MEDIUM, or HARD). Based on this classification, the system automatically ad- justs key inference hyperparameters, such the cut budget B and early stopping patience.
This allows the agent to dynamically allocate com- putational resources, applying lean budget simple problems and a more generous one to chal- lenging instances, thereby ensuring both efficiency and effectiveness without requiring the user to manually tune instance- specific parameters. This adaptive approach ensures efficient resource allo- cation while maintaining robust performance across a wide range of problem types. We define early stopping as terminating cut selection when the marginal LP bound improvement falls below dufficulty-deeedder threshold for a fixed number of consecutive iterations. Also, Max Iterations de- notes the upper bound the number of cut-selection rounds allowed per node, preventing excessively deep cut- ant-generation loops and ensuring a predictable computational budget. Table ] summarizes the adaptive inference parameters; their empirical behavior and robustness are detailed in Appendix H
Table 1: Adaptive Parameter Settings
Parameler
EASY
MEDIUM
HARD
5.8
Cut Budget (B)
10-20
20-30
30-50
Early Stop Threshold
10-4
10-b
10
Early Stop Patience
3.5 TRAINING PIPELINE OVERVIEW
For clarity, we provide brief summary of the training procedure. A detailed description of the schedule including epoch counts, update frequencies, and curriculum progression is provided in Appendix G
The learning process consists of three sequential phases.

---

Published as a conference paper at ICLR 2026
Phase 1: Expert Demonstrations. We generate state-action trajectories by running SCIP's default cut-selection policy on the training set. These demonstrations are used both to initialize the policy and to train the discriminator.
Phase 2: Adversarial Reward Learning. A discriminator Dg trained to distinguish expert trajectories from those produced by the current policy. The policy is then updated using the learned GAIL reward IGATL (s, a) = log(1 - (s(s, a)). This phase serves as the main pretraining stage.
PPO Refinement. After adversarial training stabilizes, refine the policy using PPO under the curriculum described in Section 3.3 The discriminator is fixed during this stage, and training proceeds until the early-stopping criteria met.
Phase 3:
4 PROPERTIES OF MIRACLE
To formally ground framework, establish key theoretical properties that guarantee convergence, sample complexity, and memory efficiency. Our analysis hinges on a set of standard assumptions on
Bounded Rewards B.1 Lipschitz Policy B.2 and Bounded Variance B.3 listed in the Appendix.
We first establish the bound on the sample complexity for our adversarial imitation module, confirming that effective policy can be learned with tractable number of expert demonstrations.
Proposition 4.1 (Expert Imitation Sample Complexity). achieve e-optimal performance relative to expert policy Tg, the number of expert demonstrations required is:
N H log((A1/6))
(
where H is the horizon length, |A] is the effective action space size, and 5 is the confidence parameter.
Proof. The proof relies sample complexity bounds from imitation learning (Ross et al. 2011 and is detailed in Appendix B.3
Next, we show that the PPO-based training procedure converges to a stationary point, ensuring the stability and reliability of the learning process.
Theorem 4.2 (PPO Convergence in Cut Selection). Under Assumptions B.1 B.2 and B.3 the PPO
algorithm with clipped surrogate objective converges to a stationary point of the policy optimization problem at rate O(/TT), where T is the number of iterations.
Proof. The proof follows from convergence results for policy gradient methods with surrogate objectives and is provided in Appendix B.2
Finally, provide formal guarantee for the primary contribution of our framework. The following theorem analytically models the memory reduction from our budgeted cut selection.
Theorem 4.3 (Memory Reduction Guarantee). Let Mscw and MARAALE denote the memory con- sumption of standard SCIP and MIRACLE, respectively. Then the following will hold:
MMIRACLE
MsciP < Mbore T
Miase + Crotal
where Miuse is the base memory (normalized), B is the cut budget, T is the number of iterations, and Cronat) is the total cuts generated by SCIP.
Proof. The proof follows from direct accounting of memory sources under the two strategies, detailed in Appendix B.4
This theorem provides clear analytical explanation for the dramatic memory savings observed in our experiments. This has been empirically validated and is presented in the Appendix[] The key insight is captured in the following corollary, which examines the behavior for large-scale problems.
7

---

Published as a conference paper at ICLR 2026
Corollary 4.4 (Asymptotic Memory Reduction). For large-scale problems where (Croaa]] > the memory ratio approaches:
Mouse
MMIRACLE
B-T
lim Cuaal +000
MsCIP
|Corall
explaining the observed 95-99% memory reductions in practice.
5 EXPERIMENT SETTING AND RESULTS
We conducted comprehensive empirical evaluation to validate the performance of our framework across two distinct and challenging benchmark suites: 150 SetCover instances and 150 diverse prob- lems from the MIPLIB datasets (50 instances of each difficulty level). Our experiments are designed to prove three primary claims: (1) MTRCLI achieves a significant reduction in memory usage that translates into a fundamental improvement in solver reliability: (2) This resource efficiency leads to significant and consistent speed improvements; and (3) The learned policy is robust and generalizes well, making it suitable for practical deployment. We train the policy 1000 SetCover instances using the scalable, well-structured distribution in Huang et al. 2024). and evaluate generalization exclusively unseen MIPLIB problems. We compare selection heuristics, which employ sophisticated scoring functions based on cut efficacy, parallelism, and numerical stability, and SCIP Aggressive, which utilizes enhanced cutting plane generation (maxrounds=5, maxcuts=5000), To ensure an unbiased evaluation, all solvers (SCIP-Base) Line, -eiP-Aggressive, and MIRACLE) operate under strictly identical, single-threaded conditions, with a 600-second time limit Wang et al. (202)) and 12GB memory limit, using a common PYSCIPOpt interface (Maher et al., 2016). The only difference the algorithmic strategy for cut selection. All details for implementation and reproducibility are in the Appendix
results against SCIP 8.0's default cut
Relevance of Memory Constraints. While modern servers possess ample RAM, memory remains a critical bottleneck in three key deployment scenarios: (i) edge devices (e.g.. Jetson, Raspberry Pi) with 4-hGB RAM, (ii) cloud optimization, where memory directly affects cost, and (iii) multi-tenant environments, where lower peak memory permits much higher parallel throughput. Thus, the 12GB limit in our experiments serves as a conservative proxy for these
environments.
The primary contribution of MIRACLE its exceptional memory efficiency, which directly solves the reliability crisis that memory-intensive solvers face on hard problems. Table shows a comprehensive breakdown of memory performance. On the challenging SetCover instances, MIRACLE'S peak Resident Set (RSS) memory consumption remains constant at 45-46 MB for SetCover problems, while SCIP's usage scales poorly from 1.97GB to 3.03GB. This represents a staggering 98. 1% average memory reduction (95% CI) with p 0.001 in all pairwise comparisons. Figure 2a and 2b show the memory usage and solve times across difficulties for the Set Cover instances.
Table 2: Comprehensive Memory Performance Analysis. MIRACLE maintains near-constant, minimal memory profile, achieving up to 98.5% reduction.
Benchmark
SCIP Memory
MIRACLE Memory
Reduction
Instances
SetCover-Easy
1,970.3 MB
45.4 MB
97.7%
50
SetCover-Meding
2,437.7 MB
46.1 MB
98.1%
50
SetCover-Hard
3,033.9 MB
46.2 MB
98.5%
50
MIPLIB-Smal
1,343.9 MB
415,8 MB
69.1%
50
MUPLIB-Medium
1,347.3 MB
418.2 MB
69.0%
50
LIPL.B-LLarge
2,312.3 MB
737.4 MB
68.1 %
50
Mean Value
2,073.9 MB
284.7 MB
86.3 %
300
As shown in Table on the diverse and difficult MIPLIB benchmark, MIRACLE achieves a perfect 100% success rate. The success rate is defined solving instance to a target optimality gap of 0.1% within the allotted time and memory limits. stark contrast, the traditional SCIP-Base 1 inn and SCIP-Aqqre ss ivve solvers fail 40-53% of these instances, hitting memory time limits precisely because the memory bloat our method prevents. This result demonstrates that treating memory first-class objective enables to solve problems that traditional approaches cannot. To
8

---

Published as a conference paper at ICLR 2026
Spendup Dlttrbation Roee
Medion Spandap Categery
10
Poak Memory Usage
10
Salver Easeline
10
207
roaken Problem Category
Probrem Category
(c) MIPLIB Speedup Analysis
Problem Difficulty
MIRACLE: Compretenstve Performance Anslysts
(a) Memory Reduction by Problem Difficulty
Meddon Timee
Starcese Bott
80
60
2x330
Memory Usage (MB)
3000
8
2500
CC3 Aggessiee SED4 Roc
2000
solver
1500
MIRACLE
Baseline
1500
VSPU3 Hedien Narrory
Speedi Enenine
difficllty
1000
EASY
500
MEDIUM
0
50
100
150
200
250
300
Solve (seconds)
(d) Comprehensive Performance Summary on MIPLIB
(b) Memory Usage vs. Solve Time
Figure 2: (a) Memory reduction is consistently high across problem difficulties. (b) This efficiency visualized as a clear separation in memory usage versus the baseline. (c) The memory savings translate directly into significant speedups on the MIPLIB benchmark. (d) A comprehensive summary on MIPLIB highlights MIRACLE's superior reliability (100% success), avg. speed (3.78x), and memory efficiency.
contextualize MIRACLE's memory gains, we additionally compared its peak memory usage against the hierarchical sequence model of Wang et al. (2024). Detailed results are provided in Appendix D
The reliability and memory efficiency of MIRACLE translate directly into significant computational speedups. As shown in Figure 2c our method delivers consistent speed advantages across all MIPLIB problem categories. The median speedup ranges from 2.50x to 4.79 over the baseline. This demonstrates that by learning to select a small, high-impact set of cuts, the solver spends less time managing large cut pools and more time on productive optimization. All speed improvements are statistically significant (p 0.001) and have large effect sizes. The consistent performance across SetCover and MIPLIB demonstrates that MIRACLE captures general cut-selection principles rather than dataset-specife artifacts. Across all 300 instances, observe large, statistically significant gains: an average memory reduction of 86.3% and a 3.78x speedup, with reliability improving from 47-53% (SCIP) 100%. These results highlight MIRACLE'S robustness and suitability for real-world, resource-constrainee deployment.
Figure provides an integrated view of MIRACLE's achievements, which collectively establish it as memorr-efficcient optimization. The key insight from our comprehensive evaluation is that MIRACLE delivers significant memory efficiency, achieving an average reduction of 86.3% across 300 instances and up to 98.1% on the most challenging problems. This efficiency underpins the framework's 's reliability, evidenced by a 100% success rate on difficult MIPLIB instances where traditional SCIP fails 47-53% of the time. This reliability and efficiency translate directly into consistent speedups, averaging 3.78x across both SetCover and MIPLIB problems. Furthermore, our method shows strong generalization, maintaining robust performance across diverse problem types and hyperparameter configurations. All of these improvements are statistically significant (p < 0.001) and have large effect sizes, enabling their deployment in previously inaccessible, resource-constrained environments while maintaining competitive solution quality.
To verify that results stem from the core algorithmic design rather than fragile hyperparameter tuning, we conducted extensive ablation studies. The results are summarized in Table 4 Across various cut budgets (10-50), iteration limits (1-10), and early stopping criteria, the average speedup

---

Published as a conference paper at ICLR 2026
Table 3: MIPLIB Performance Comparison: Reliability and Speed. MIRACLE achieves 100% success where baselines frequently fail, while also being significantly faster.
Solver
Category Success Rate
Median Time
Speedup
Large
53.3%
577.5s
1.00x
SCIP- SCir-Aggress
Large
46.7%
600.0s
0.96x
MIRACLE
Large 100.0% %
125.7s
4.59x
clusters tightly between 1.15x-1.174 while the memory reduction remains consistently above 99%. This robustness indicates that MIRACLE's learned policy generalizes well and is suitable for real-world deployment where reliability essential. More details can be found in Appendix
Table 4: Inference-Time Ablation Study Results on SetCover problems (30 instances per category configuration)
Configuration
Avg Speedup
Std Dev
Cut Red.
Avg Iters
95% CI
Cut Budget 10
1.170
0.452
99.1%
1.1
[0.997, 1.343]
Cut Budget 30
1.164
0.442
99. %
1.1
[0.996, 1.332]
Cut Budget 50
1.157
0.427
99.1%
1.1
[0.996, 1.318]
Max Iterations 1
1.163
0.443
99.1%
1.0
[0.995, 1.331]
Max Iterations 5
1.163
0.439
99.1%
1.1
[0.996, 1.330]
Max Iterations 10
1.166
0.447
99.1% %
1.1
[0.996, 1.336]
Aggressive Early Stop
1.166
0.445
99.1%
1.0
[0.996, 1.336]
Current Baseline
1.164
0.445
99.1%
1.1
[0.995, 1.333]
Very Lenient Early Stop
1.162
0.438
99.0%
1.2
[0.996, 1.328
No Early Stop
1.164
0.448
99.0%
1.1
[0.995, 1.333]
Although MIRACLE imitates SCIP's selection patterns, it consistently selects far fewer cuts (99% reduction), which substantially decreases the size of the evolving LP relaxation. This reduces SCIP's internal LP solve time and cuts management overhead, yielding faster overall solving despite mimicking expert behavior. This explains why MIRACLE attains notable speedups without modifying SCIP's underlying branching or presolving components.
To demonstrate that MIRACLE captures fundamental cut-selection principles rather than domain- specific patterns, we evaluated the model (trained solely on SetCover) across three distinct problem classes without retraining: Combinatorial Auctions, Maximum Independent Set (MIS), and Facility Location. As detailed in Appendix [ MIRACLE generalizes robustly. On Combinatorial Auctions (423 instances) and Facility Location (100 instances). it achieves 100% success rate with cut reductions of 98.8% and 99.9%, respectively. Notably, in MIS instances where baseline approaches often struggle with dense LP relaxations, MIRACLE achieved a 100% success rate compared to the baseline, reducing the average number of cuts from ~1 1,900 to just 10.1 while maintaining neutral-to-pon -oosiiive speedup. This confirms that the learned policy identifies high-violation, sparse cuts strategy that is problem-agnostic.
CONCLUSION
We have shown that selection can be effectively reframed an RL problem which memory efficiency is treated as first-class objective. MIRACLE combines PPO-based policy learning, adversarially learned rewards, and adaptive inference to produce a lightweight and reliable cut- selection mechanism. Across 300 instances spanning SetCover and diverse MIPLIB categories, MIRACLE achieves dramatic memory reductions (up to 98.1%) and consistent speedups, while achieving 100% success rate the hardest MIPLIB problems where traditional SCIP frequently fails. These improvements are statistically significant and remain stable across hyperparameter settings, underscoring the robustness of the learned policy. Our results demonstrate that substantial memory savings and reliability gains are achievable without sacrificing solution quality, enabling deployment in resource-constrained environments previously inaccessible classical solvers.
10

---

Published as a conference paper at ICLR 2026
REPRODUCIBILITY STATEMENT
We have taken several steps to ensure the reproducibility of our work. An anonymized version of our code, along with data splits and scripts for reproducing all experiments, will be made available upon acceptance. All algorithmic details described in Section with theoretical assumptions and proofs in Appendix [ The experimental setup. including dataset composition, training protocols, and evaluation metrics, is provided in Section / and further detailed in Appendix A comprehensive reproducibility checklist with model architectures, hyperparameters, and hardware specifications is included in Appendix
ACKNOWLEDGEMMEN
HK and MCR gratefully acknowledge the financial support received from the DST-SERB (ANRF), India (File No. CRG/2022/003722). We acknowledge the Yardi School of at IIT Delhi for its support for this research and for providing travel grant. HK and AM acknowledge IIT Delhi-Abu Dhabi for support this research.
REFERENCES
Robert E Bixby, Mary Fenelon, Zonghao Gu, Ed Rothberg, and Roland Wunderling. Mixed-integer programming: A progress report. In The sharpest cut: the impact of Manfred Padberg and his work, pp. 309-325. SIAM, 2004.
Zixuan Cao, Yang Xu, Zhewei Huang, and Shuchang Zhou. MI4co-kida: Knowledge inheritance in dataset aggregation. arXiv preprint arXiv:2201. 2022.
Arnaud Deza and Elias B Khalil. Machine learning for cutting planes in integer programming: A survey, arXiv preprint 2tt.:::33020096666 2023.
Chelsea Finn, Paul Christiano, Pieter Abbeel, and Sergey Levine. A connection between generative adversarial networks, inverse reinforcement learning, and energy-based models. arXiv preprint arXiv:1611.03880 2016.
Gerald Gamrath, Daniel Anderson, Ksenia Bestuzheva, Wei-Kun Chen, Leon Eifler, Maxime Gasse, Patrick Gemander, Ambros Gleixner, Leona Gottwald, Katrin Halbig, et al. The seip optimization suite 7.0. 2020.
Maxime Gasse, Didier Chételat, Nicola Ferroni, Laurent Charlin, and Andrea Lodi. Exact combi- natorial optimization with graph convolutional neural networks. Advances in neural information processing systems, 32, 2019.
Ian J Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. Advances in neural information processing systems, 27, 2014.
Jonathan Ho and Stefano Ermon. Generative adversarial imitation learning. Advances in neural information processing systems, 29, 2016.
Weimin Huang, Taoan Huang, Aaron M Ferber, and Bistra Dilkina. Distributional miplib: multi- domain library for advancing ml-guided milp methods. arXiv preprint 24XX::2406006544 2024.
Zeren Huang, Kerong Wang, Furui Liu, Hui-Ling Zhen, Weinan Zhang, Mingxuan Yuan, Jianye Hao, Yong Yu, and Jun Wang. Learning to select cuts for efficient mixed-integer programming. Pattern Recognition, 123:108353. 2022.
Elias Khalil, Hanjun Dai, Yuyu Zhang, Bistra Dilkina, and Le Song. Learning combinatorial optimization algorithms over graphs. Advances in neural information processing systems, 30, 2017.
11

---

Published as a conference paper at ICLR 2026
Stephen Maher, Matthias Miltenberger. João Pedro Pedroso, Daniel Rehfeldt, Robert Schwarz, and Felipe Serrano. PySCIPOpt: Mathematical programming in python with the SCIP optimization suite. In Mathematical Software ICMS 2016, pp. 301-307. Springer International Publishing, 2016. doi: 10. 10.1007/97--3-319-22444
37.
Kip Nieman, Helen Durand, Saahil Patel, Daniel Koch, and Paul M Alsing. Parallelizing process model integration for model predictive control through oracle design and analysis for a grover's Seporithm-inspiree optimization strategy. Digital Chemical Engineering, pp. 100179, 2024.
Max B Paulus, Giulia Zarpellon, Andreas Krause, Laurent Charlin, and Chris Maddison. Learning to cut by looking ahead: Cutting plane selection via imitation learning. In International conference on machine learning, pp. 17584-17600 17600. PMLR, 2022.
Yves Pochet and Laurence Wolsey. Production planning by mixed integer programming. Springer, 2006.
Stéphane Ross, Geoffrey Gordon, and Drew Bagnell. reduction of imitation learning and structured prediction to no-regret online learning. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, pp. 627-635, JMLR Workshop and Conference Proceedings, 2011.
John Schulman, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel. High-dimensional continuous control using generalized advantage estimation. arXiv preprint arXiv: 02438, 2015.
John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.066 2017.
Yunhao Tang, Shipra Agrawal, and Yuri Faenza. Reinforcement learning for integer programming: Learning to cut. In International conference on machine learning, pp. 9367-9376. PMLR, 2020.
Jie Wang, Zhihai Wang, Xijun Li, Yufei Kuang, Zhihao Shi, Fangzhou Zhu, Mingxuan Yuan, Jia Zeng, Yongdong Zhang, and Feng Wu. Learning to cut via hierarchical sequence/set model for efficient mixed-intege programming. IEEE Transactions on Pattern Analysis and Machine Intelligence. 2024.
ShengChao Wang, Sheng-Jie Chen, and Liang Chen. Cut selection in milp based on supervised learning. Procedia Computer Science, 221:1408-1415 2023.
Laurence Wolsey, Integer programming. John Wiley Sons, 2020.
Xuefeng Zhang, Liangyu Chen, and Zhenbing Zeng. Learning select cutting planes in mixed integer linear programming solving. arXiv preprint 4xXiv:2410.03112.200000 2024.
APPENDIX
A NOTATION SUMMARY
Table 5 summarizes the mathematical notation used throughout the paper to describe the MDP and training process.
B DETAILED PROOFS
B. ASSUMPTIONS
Assumption B.1 (Bounded Rewards). The reward function is bounded: Ir(s, a)l < Ruax for all
(s, a). where Rmax > is the finite reward bound, and advantages satisfy A a) < Amaze where Amax O is finite advantage bound.
12

---

Published as a conference paper at ICLR 2026
Table Summary of Notation.
Symbol
Description
M
Markov Decision Process tuple P,, State and Action at iteration k Set of candidate cuts available iteration k: Cut selection budget (maximum cuts to select) Policy network parameterized by Discriminator network parameterized by
8k, Ak Ck
B
m
D&
Ve
Value network parameterized by ø Learned reward signal from the discriminator
TGAIL
T1.8
Sequence of internal SCIP operations (expert trajectory)
Pk(0)
Probability ratio for PPO updates
Assumption B.2 (Lipschitz Policy). The policy me is L-piicchhttz parumeters: ||TO - -Tosllo0 S 01 02112 ll V 01, 0g
Assumption B.3 (Bounded Variance). The gradient estimates have bounded variance: B|| V(( V < o², the upper bound on the gradient variance.
B.2 PROOF OF THEOREM 4.2 (PPO CONVERGENCE)
Proof. We prove convergence of PPO the cut selection setting by showing that the clipped surrogate objective provides lower bound on policy improvement.
Let Told be the current policy and π be the updated policy. The PPO objective is:
L CLIP (x) Er [min (r*(TT) (l)pp(rrr)))) -, +)1+))A))
(13)
where (Tr
=(allse) (x) Rad (oz (s;) and A, is the advantage estimate.
Step 1: Lower Bound on Policy Improvement For any policy æ, the policy improvement can be bounded as:
(TT) - ((Tol)) 2 CLPP (T)) C. [DKL (-1))
(14)
where C' 227Amx and Amax is the maximum advantage (Assumption B.1 (1-7)²
Step 2: Clipping Analysis The clipping mechanism ensures monotonic improvement while prevent-
ing destructive updates. For positive advantages (A, 0); r. 2 1+ L (T) (1 e)A,
(conservative improvement) If (T))) < 1 e: L (T) = (1 - A) (prevents degradation).
Otherwise: CLPP (x) re (r) (standard policy gradient)
Step 3: Convergence Rate Under Assumption B.2 the KL divergence can be controlled:
Dx T) S L 10 w < 1.
(15)
Choosing step size S CDर ensures the KI. penalty doesn't 't dominate policy improvement.
Step 4: Stationary Point Convergence Standard gradient ascent analysis with bounded gradients yields:
T T
(0)13) CLL (0,)
CLIP (8*)) + no²
(16)
1/
Setting 77 O(L/VT) yields the O(1/T) convergence rate to stationary point.
B.3 PROOF OF PROPOSITION 4.1 (SAMPLE COMPLEXITY)
Proof.
We analyze sample complexity for achieving near-expert performance through GAIL regular-
ization.
13

---

Published as a conference paper at ICLR 2026
Step 1: Action Space in Cut Selection Each cut selection action is binary vector with budget constraint aa
ag I B. The effective action space size is:
[max
[e/Cmxx]
B
Aenl
(17)
Step 2: Generalization Bound Using empirical process theory, with probability 1 8:
/ (20g((26)) RN(FF)
Lespen (0)
exppet
cmmirical
(0) S
(18)
N
where Rw((F is the Rademacher complexity of the policy function class.
Step Performance Gap Analysis The difference expected return bounded by:
J(mg) ((x - 2H log A + log(1/5)
(19)
N
Since typical cut budgets B = 10 50 are small, log | = O(B log Cmaxl).
Setting the bound equal to and solving for N yields the stated sample complexity.
B.4 PROOF OF THEOREM 4.3 (MEMORY REDUCTION)
Proof. We analyze the memory consumption difference between SCIP and MIRACLE.
Step 1: Memory Decomposition Standard SCIP memory: MSCIP
Muuse MS MIRACLE
memory: MMIRACLE = Mbsse + MM MIRACLE + Mpolicy
cuts
where Mpaticy is negligible (17K parameters 4 bytes 68KB).
Step 2: Cut Memory Analysis SCIP accumulates up to [Cunal cuts over the entire solving process MTRACLE, stores most B cuts per iteration for T iterations, with efficient deletion of unselected cuts
Therefore:
M MIRACLE < B. Ceut and S
|Cinaal
Cout
Step 3: Memory Ratio Bound
MMIRACLE
Maase + B. T Cent + Mpolicy
(20)
MscIP
Mause + (Cutal Geut
Neglecting Mpolicy and normalizing by Can gives the stated bound.
Step 4: Practical Validation our experiments: - [Cotal =s 10, 000 100, 000 cuts (SCIP generates many cuts) B 50 500 cuts (MIRACLE selects few cuts) Memory ratio 1-5%, explaining observed 95-99% reductions
C PRELIMINARIES IN INTEGER PROGRAMMING
An Integer Programming (IP) problem seeks to optimize a lincar objective over a set of integer variables subject to linear constraints. It can be formally expressed as:
min T I S.t. Ar -, x E
(21)
where A E m b E R and c E R". The standard solution approach begins by solving the problem's continuous LP relaxation, where the integrality constraint is temporarily ignored. The feasible region for this relaxation is the polyhedron p(0) {i E n Ar < 6}. which yields an optimal solution [
(0) If LLP is fractional, the cutting plane method is employed iteratively refine this feasible region. At each iteration k a linear inequality, known as cut, is added to the problem. cut, denoted by 0g < Br, must satisfy two key properties:
14

---

Published as a conference paper at ICLR 2026
(k) 1. It violated by the current fractional solution: 0g LLP 3k.
2. is satisfied by all feasible integer solutions, ensuring no valid solutions are removed.
(R) This cut "cuts off" the fractional solution Zip from the feasible set, creating a new, tighter polyhedron for the next iteration:
plk+1) = p(4) n for 0 [ S }x}
(22)
The LP then re-solved over this smaller region p(k-1) find new solution (b+1) iterative process continues until integer-optimal solution is found.
zip and this
D NEURAL NETWORK ARCHITECTURE DETAILS
Our MIRACLE framework employs carefully designed neural architecture optimized for cut selec- tion mixed-integer programming. The architecture consists of three main components: a policy network for cut selection, value network for advantage estimation, and discriminator network for adversarial reward learning.
D.I POLICY NETWORK ARCHITECTURE
The policy network Th (a (a)s) implemented as Multi-Layer Perceptron (MLP) designed for efficient cut selection:
Input Layer: Accepts state representations E 1010 containing cut features
Hidden Layer 1: 128 neurons with ReLU activation
Hidden Layer 2: 128 neurons with ReLU activation
Output Layer: Variable size based on number of candidate cuts, with softmax activation
Total Parameters: Approximately 17,000 parameters
The network processes cut features, including the number of non-zeros, left-hand side, right-hand side, locality flags, and structural properties. The output produces probability distribution over candidate cuts for top-K K selection.
D.2
VALUE NETWORK ARCHITECTURE
The value network V*( estimates state values for PPO training:
Input Layer: Same 10-dimensional state representation as policy network
Hidden Layer 1: 128 neurons with ReLU activation
Hidden Layer 2: 128 neurons with ReLU activation
Output Layer: Single scalar output (no activation)
Total Parameters: Approximately 16,500 parameters
D.3 GAIL DISCRIMINATOR ARCHITECTURE
The discriminator network (s, a) for adversarial reward learning uses deeper architecture:
Input Layer: Concatenated state-action pairs [s; e IRd
Hidden Layer 1: 256 neurons with ReLU activation
Hidden Layer 2: 256 neurons with ReLU activation
15

---

Published as a conference paper at ICLR 2026
Hidden Layer 3: 128 neurons with ReLU activation
Output Layer: Single neuron with sigmoid activation (binary classification)
Total Parameters:
Approximately 100,000 parameters
D.4 TRAINING HYPERPARAMETERS
Table 6: Neural Network Training Configuration
Parameter
Value
Learning Rate (Policy/Value)
10
Learning Rate (Discriminator)
x 10
Batch Size
64
PPO Epochs per Update
4
Discount Factor (7)
0.99
GAE Parameter (X)
0.95
Clip Coefficient (c)
0.2
Entropy Coefficient
0.01
Value Function Coefficient
0.5
E
PSEUDO CODE
Algorithm 1 MIRACLE:
Model-free Imitation and Reinforcement Learning for Adaptive Cut-
Selection
Require: Expert trajectories DE TE (from SCIP), problem instances P Ensure: Trained cut selection policy me Initialize actor-critic policy To (with value function V&A) Initialize discriminator Di:
1:
2:
> Phase I: Adversarial Reward Learning (Pre-training Concurrent)
3: Sample agent trajectories Dø Te by running the policy on P
4: Update discriminator Di by minimizing the GAIL loss on DE and Dy:
5: LD t -B(a [log Dv(s,a)] - ((a.o)-D, [log[1 (ly
D Phase 2: Policy Optimization with Curriculum Learning 6: for each curriculum stage in (EASY, MEDIUM, HARD, MIXED) do
7:
for episode 1 to N Nppisodes do
8: Initialize SCIP environment with problem from the current stage
9:
Run policy me for H steps, collecting trajectory {(5k, ag }k=
)
b Inside episode loop
10:
for each step l in the trajectory do Compute dense reward using the discriminator: ти + log(1 ( (o(sk)aa)) ax))
11:
end for
13:
Compute advantage estimates ÅŞ for all steps in using GAB(A)
Update policy Tee by maximizing the PPO surrogate objective CCLIP (0)
15:
Update value function Vo by minimizing the value loss CVF (v)
end for
17:
end for
Deployment Phase: Adaptive Inference
18: function SOLVEINSTANCE(Pee)
19:
Classify problem difficulty d' +- Classify(Pued)
20:
Set adaptive budget B and other parameters based on d
21:
Run trained policy ne within the SCIP environment solve the instance
22:
end function
16

---

Published as a conference paper at ICLR 2026
F EXTENDED EXPERIMENTAL RESULTS
F.1 RAW DESCRIPTIVE STATISTICS
Tables 7 and provide raw summary statistics of memory usage and reduction percentages by difficulty. These highlight the consistency of the 97-99% memory savings.
Table Raw memory usage statistics (MB) by solver and difficulty.
Solver
Difficulty
Count
Mean
Median
Std
Range
MIRACLE
EASY
50
46.1
45.4
8.6
[30.3, 60.0]
MIRACLE
MEDIUM
50
46.1
46.1
8.0
[30.5, 59.2]
MIRACLE
HARD
50
45.7
46.2
8.7
[30.5, 59.7]
SCIP
EASY
50
1974.8
1970.3
169.8
[979.1, 2324.7]
SCIP
MEDIUM
50
2449.4
2437.7
104.0
[2242.8, 2836.4]
SCIP
HARD
50
3043.0
3033.9
94.3
[2883.8, 3259.9]
Table 8: Absolute and percentage memory reduction by difficulty.
Difficulty
Mean Red. (MB)
Median Red, (MB)
Std (MB)
Mean Red. (%)
Median Red. (%)
Std (%)
EASY
1928.7
1921.6
170.0
97.6
97.8
0.6
MEDIUM
2403.3
2394.0
105,4
98.1
98.
0,4
HARD
2997.3
2982.7
95.1
98.5
98.5
0.3
F.2
DETAILED ABLATION STUDY RESULTS
The complete detailed results of the ablation studies given in Table and can be visualized using Figure
Table 9: Complete Ablation Study with Statistical Measures
Configuration
Median
Mean
Std
IQR
Cut Red.
p-value
Cut Budget TO
0.990
1.170
0.452
[0.98, 1.34]
99.1%
0.023
Cut Budget 20 (Baseline)
0.990
1.164
0.445
[0.98, 1.33]
99.1%
Cut Budget 30
0.996
1.164
0.442
[0.99, 1.33]
99.1%
0.891
Cut Budget 50
0.996
1.157
0.427
[0.99, 1.32]
99.1%
0.445
Max Iter
0.995
1.163
0.443
[0.99, 1.33]
99.1%
0.967
Max Iter 5 (Baseline)
0.990
1.164
0.445
[0.98, 1.33]
99.1%
Max Iter 10
0.996
1.166
0.447
[0.99, 1.34]
99.1%
0.823
Aggressive Early Stop
0.996
1.166
0.445
[0.99, 1.34]
99.1%
0.823
Normal Early Stop (Baseline)
0.990
1.164
0.445
[0.98, 1.33]
99.1%
Lenient Early Stop
0.996
1.162
0.438
[0.99, 1.33]
99.0%
0.845
No Early Stop
0.995
1.164
0.448
[0.99, 1.33]
99.0%
0.998
F.3 PER-INSTANCE ANALYSIS
Figure shows the per-instance speedup and memory reduction across all 300 evaluated instances, demonstrating the consistency MIRACLE's improvements.
G TRAINING PROCEDURES
We collect expert demonstrations running SCIP with default parameters on 1000 training instances, recording state-action pairs whenever SCIP adds cuts. Each demonstration includes:
Expert Data Collection
17

---

Published as a conference paper at ICLR 2026
Geometric MMan Spee
Cut Reduction (%)
100
Speedup Distributio
2.5
1.15
75
2.0
1.10
50
1.5
1.05
25
1.0
1.00
0
20
30
30
Cut Budget
Cut Budget
Cut Budget
Figure 3: Cut budget ablation showing robust performance across budget ranges 10-50. Both speedup and cut reduction remain stable, indicating effective resource adaptation.
Statistical Significance Matrix (Mann-Whitneyy Test)
(p-0.001)
Budgct 50
04422
A112
0333
0.291
0.35
5.00
540
Max terations
13
Current Beseline
932
6A12
0.91
0.392
034
0.39
985
Confiquraion
Out Dudget JU
6.00
0.61p
0.35
0333
000
0.23
6041
094
Ageressive Early Stop
* (p-c0.05 051
Lenient Early
6.35
947
0.99
0355
6902
912
6.005
No Early Stop
800
030
65
85
0.76
95
Cuc Budget 10
8.50
0377
0.76
0323
Busgee 50
Mas Reratera g
Careet Baontine
Hax Berations
Cat Budget 30
Iterations
Agpemetive Early Stap
Very Lemient Earry Stop
Early Stop
Gut Burtget 10
Configunett gunetinn
Figure 4: Per-instance analysis showing speedup memory reduction for all 300 instances. Points above the diagonal indicate instances where both metrics improve simultaneously.
LP state features (solution values, bounds, violations)
Cut characteristies (coefficients, sparsity, type, efficacy)
SCIP's binary selection decisions
Curriculum Learning Schedule
1. Phase 1: 50 episodes on instances with 200-500 constraints
2. Phase 2: 100 episodes instances with 500- 100- constraints
18

---

Published as a conference paper at ICLR 2026
3. Phase 3: 100 episodes instances with 1000-2000 constraints
4. Phase 4: 100 episodes mixed difficulty (fine-tuning)
G.1 TRAINING PIPELINE TIMELINE
To ensure stability, training proceeds three distinct sequential phases:
1. Phase 1: Expert Data Collection (Offline). We execute SCIP on 1,000 training instances, recording state-action pairs (s, (empert) form the expert dataset Dg. The policy is updated during this phase.
2. Phase 2: Adversarial Reward Learning (Epochs 0-50). The Discriminator Dy is trained to distinguish between expert actions and policy actions. The Generator (Policy) me is pre-trained to mimic expert behavior using the GAIL signal.
3. Phase 3: PPO Refinement (Epochs 51-150). The Discriminator is frozen. The Policy my fine-tuned using PPO to maximize the fixed reward signal TGAIL. effectively optimizing the learned strategy for robustness and generalization.
Hyperparameter Selection All hyperparameters were selected via grid search on held-out validation set:
Learning rates tested: {le 5,3c 4, 3,3e 3}
PPO clip values tested: 0.2,
Expert regularization weights tested: [0.01,0.1, 0.5,
GAE lambda values tested: {0.9, 0.95, 0.99}
G.2 TRAINING CONVERGENCE ANALYSIS
We monitored the stability of the training process across the three phases. Table IO summarizes the final convergence metrics, demonstrating that the adversarial training stabilizes effectively.
Table 10: Training Convergence Metrics (Final Epoch).
Metric
Initial Value
Final Value (Epoch 150)
Policy Loss
2.01
0.20
Discriminator Accuracy
90.5%
58.9%
Validation Reward
0.31
0.807
The Discriminator accuracy converging to ~ 60% (near random guess of 50%) indicates that the generator (policy) has successfully learned produce cut selections that are indistinguishable from the expert, satisfying the GAIL objective.
G.3 COMPUTATIONAL ENVIRONMENT
Hardware Specifications
GPU: NVIDIA RTX 3080 (10GB VRAM)
CPU: Intel 17-10700K (8 cores, 3.8GHz base)
RAM: 32GB DDR4-3200
Storage: 1TB NVMe SSD
19

---

Published as a conference paper at ICLR 2026
Software Environment
Operating System: Ubuntu 20.04.3 LTS
Python: 3.9.7
PyTorch: 1.12.1 with CUDA 11.6
PySCIPOpt: 4.3.0 with SCIP 8.0.2
Additional Libraries: NumPy 1.21.2, SeiPy 1.7.3, Matplotlib 3.5.1
H
ADDITIONAL DETAILS ON ADAPTIVE INFERENCE
Table in the main paper summarizes the hyperparameters used to control MIRACLE's adaptive cut-selection process. For completeness, we clarify their operational meaning and empirical behavior.
Factor
Contribution
Evidence
Fewer Cuts
60-70%
99.1% 1% cut reduction correlates with speedup
Better Quality
20-25%
Feature importance shows violation/iteration focus Inference overhead 0.5%
Reduced Overhead
5-10%
Adaptive Inference
5-10%
Adaptive vs. fixed budget comparison
Table 11: Decomposition of performance contributions.
The cut budget specifies the maximum number of cuts that MIRACLE may add in single round. Max Iterations bounds the total number of cut- out-generation rounds at a node, ensuring that inference cannot enter excessively deep eut loops. The early-stop threshold terminates cut selection once the marginal LP-bound improvement falls below difficulty-specific tolerance for fixed number of consecutive rounds.
Across all difficulty tiers, we observe that MIRACLE's performance is largely insensitive to these parameters. Varying the budget iteration limits changes overall speedup by less than 2% and memory reduction by less than 0.5%, indicating that MIRACLE requires no per-instance tuning inference time. These results complement the ablations in the main paper and demonstrate the robustness of the adaptive inference scheme.
I REPRODUCIBILITY CHECKLIST
1.1 CODE AND DATA AVAILABILITY
Upon acceptance, we will release:
Complete implementation code with documented APIs
Trained model checkpoints for all reported experiments
Generated datasets with preprocessing scripts
Evaluation scripts for all benchmarks and baselines
Configuration files for all experimental settings
1.2
EXPERIMENTAL REPRODUCIBILITY
To ensure reproducible results;
All random seeds fixed (NumPy: 42, PyTorch: 42, SCIP: 1337)
20

---

Published as a conference paper at ICLR 2026
Legend
EASY
MEDIUM
10c
HARD
Theoretical bound on memoory rablo
Easy bound
Medium bound
AYA-
10-1
500
1000
1500
2000
Baseline total cuts [Gunal
Figure 5: SetCover theoretical lower bound the memory ratio MIRACLE/SCIP function of baseline total cuts. Points are per-instance bounds; dashed lines are the minimum bound per difficulty.
Single-threaded execution enforced in SCIP
Identical hardware specifications documented
Complete dependency versions specified in requirements.tx
Docker containerization for environment consistency
1.3
COMPUTATIONAL REQUIREMENTS
Training Time: 6 hours RTX 3080 for full curriculum
Inference Time: 0.12 seconds per cut selection decision
Memory Requirements: 8GB GPU memory for training, 2GB for inference
Storage: 50GB for datasets, 100MB for trained models
PROOF OF MEMORY REDUCTION GUARANTEE
Table 12: Memory reduction Guarantee proof. We use Mi (normalized), budgets B and iterations T' from the adaptive policy, and median [Cuoat) Empirical ratios are medians of MMIRACLE/ME This for the SetCover problems.
Difficulty
B
T
[Coeal
M hose (normalized)
My B-T 35 hase Craaal
MMTRACLE MsciP
Easy
10
1
0
100
1.10
0,022
Medium
20
3
1024
100
0.142
0.019
Hard
30
6
3009
100
0.132
0.015
21

---

Published as a conference paper at ICLR 2026
K EXTENDED GENERALIZATION RESULTS
We evaluated the MIRACLE agent, trained exclusively on SetCover instances, on three additional
problem classes to assess its out-of-distribution generalization. Table 13 summarizes these results.
Table 13: Generalization performance on unseen problem classes (Model trained on SetCover).
Problem Class
Instances
Baseline Success
MIRACLE Success Success
Avg. Speedup
Avg. Cut Red.
Median Cut Red.
Set Cover (In Domain)
150
66.7%
100.0%
1.300x
99.1%
99.1%
Combinatorial Auction
423
100.0%
100.0%
1.283x
98.8%
98.4%
Max Independent Set
150
100.0%
100.0%
1.007
99.9%
99.8%
Facliiy Location
100
100.0%
100.0%
1.198x
99.9%
99.9%
The results indicate that MIRACLE maintains a cut reduction rate of > 98% across all domains
while matching exceeding baseline solving speeds. This supports the hypothesis that the policy learns the geometric properties of valid cuts (such as sparsity and violation magnitude) rather than problem-specific structures.
L COMPARISON OF MIRACLE WITH WANG ET AL. (2023)
We benchmarked MIRACLE against the method of Wang et al. (2024) on 20 randomly selected SetCere-aaay instances, using the authors' official implementation. The results, summarized in Table [4] show that MIRACLE achieves approximately 10x reduction in memory usage compared to their hierarchical sequence model.
Table 14: Peak memory usage comparison 20 SetCover-Easy instances.
Solver
Avg. Memory Usage (MB)
MIRACLE
46
Wang et al. (2023)
500
SCIP Baseline
1,975
Although prior work - including Wang et al. 2024 does not explicitly emphasize memory efficiency, MIRACLE is designed with memory reduction a primary objective. The above experiment confirms that MIRACLE provides a substantial improvement in peak memory utilization, achieving an order- of-magnitude reduction relative the strongest learned baseline.
M POLICY INTERPRETATION AND LEARNED PATTERNS
To understand MIRACLE's decision makknng process, we analyzed the feature importance weights of the trained policy network. The policy utilizes 10-dimensional state representation. Our analysis reveals that the most critical features drive the selection of cuts that resolve fractional variables.
Feature Importance: The top weighted features correspond to the fractionality values of the variables involved in the cut (Indices 1-9 of the state vector). Specifically, the raw fractionality of the 2nd through 8th most fractional variables carries the highest weight (Importance 0.16 0.17).
Learned Behaviors:
Sparsity Preference: The policy consistently rejects dense cuts, favoring cuts with 20% non-zero entries. This directly contributes to memory efficiency by keeping the LP relaxation sparse.
Early-Stage Activity: Approximately 80% of selected cuts occur within the first 5 iterations. The policy learns that late-stage cuts often yield diminishing returns in bound improvement relative to their computational cost.
High Violation Target: The policy acts as filter, rejecting cuts with violation < 10 4 ensuring that added constraints significantly tighten the relaxation.
22

---

Published as a conference paper at ICLR 2026
N COMPREHENSIVE ABLATION STUDIES
N.1
CURRICULUM LEARNING ANALYSIS
We evaluated the impact of weighted curriculum learning strategy against three baselines: No Curriculum (Random), Sequential (Fasy - Hard), and Reverse (Hard - Easy).
Table 15: Impact of Curriculum Learning Strategies (45 Test Instances).
Strategy
Avg Speedup
Success Rate
Training Stability
No Curriculum Sequential (Easy + Hard)
1.11x
94%
Low
1.11x
98%
Moderate
Reverse (Hard + Easy)
1.11x
92%
Moderate
Weighted (Ours)
1.34x
100%
High
As shown, the Weighted Curriculum yields 20.4% improvement in speedup compared sequential or random strategies. It stabilizes training by ensuring consistent exposure to easy instances while progressively up-weighting harder instances.
N.2 RL ALGORITHM AND ARCHITECTURE SELECTION
We compared PPO against TRPO and SAC. As shown in Table 16 differences in speedup were statistically insignificant (p > 0.05), validating the choice of PPO for its stability and simplicity.
Table 16: Performance comparison of RL algorithms 45 test instances.
Algorithm
Avg Speedup
Median Speedup
Cut Reduction
Significance (vs PPO)
PPO (Ours)
1.338x
0.986
99.3%
TRPO
1.355
0.986x
99.3%
p 0.79 (ns)
SAC
1.332x
0.987
99.3%
p = 0.80 (ns)
N.3
NETWORK ARCHITECTURE AND EXPERT DATA SIZE
We analyzed the impact of model depth and the number of expert demonstrations used for training. Table 17 confirms that lightweight 2-layer MLP and 1,000 expert instances provide the optimal trade-off between performance and computational cost.
Table 17: Ablation on Model Architecture and Training Data Size.
Ablation Type
Configuration
Avg Speedup
Cut Red.
Parameters/Cost
2-Layer MLP
1.163x
99.3%
19,586 (Optimal)
Architecture
3-Layer MIL
1.161x
99.3%
36,354 (+0.2% gain)
300 Instances
1.092x
99.2%
2.5 CPU-hrs
Data Size
500 Instances
1.093x
99.3%
4.2 CPU-hrs
1000 Instances
1.093x
99.3%
8.3 CPU-hrs
O
DEPLOYMENT SCENARIOS
The memory efficiency of MIRACLE enables MIIPP optimization in scenarios previously inaccessible standard solvers:
1. Edge AI & IoT: Embedded devices (e.g., Raspberry Pi 4, Jetson Nano) often have hard memory caps of 4GB, Baseline SCIP (Median 2.5GB) risks OOM crashes when background processes fluctuate. MIRACLE (Median 46MB) provides safety factor of 50x.
23

---

Published as a conference paper at ICLR 2026
2. Cloud Cost Optimization: On AWS, upgrading from t3 -argee (&GB RAM, $0.08/hr) to a t3. xlarge (16GB RAM, $0.16/hn doubles the cost solely to accommodate memory spikes. MIRACLE enables high-reliability solving the cheaper instance tier.
3. Shared Tenancy:
In high- perforrmoe computing (HPC) clusters, memory bandwidth and capacity are shared. MIRACLE allows for massive parallelization (e.g., running 8+ concurrent solvers on single node), where baseline SCIP would bottleneck 2 concurrent instances.
P EXPERIMENTAL ANALYSIS AND VERIFICATION
P.1 IMPACT OF MEMORY CONSTRAINTS
To address concerns about the 12GB memory limit, we evaluated performance both with and without it. Table 18 shows that MIRACLE maintains 100% reliability regardless of limits, whereas the baseline fails significantly when constraints are applied.
Table 18: Impact of 12GB Memory Limit on Solver Success and Efficiency (60 Instances).
Setting
Method
Success Rate
Median Time
Memory (MB)
Failures
Baseline MIRACLE
73.3% 100.0%
30.77s 60.06s
334.3
16 (Timeouts)
No Memory Limit
0.65
Baseline
69.0%
23.15s
26.5
18 (OOM/Timcouts)
12GB Limit
MIRACLE
100.0%
60.73s
8.2
P.2
VERIFICATION OF THEORETICAL ASSUMPTIONS
Our theoretical convergence guarantees rely on assumptions of Bounded Rewards (A..) and Lipschitz Policy (A.2). We empirically verified these values during training, as shown in Table
Table 19: Empirical Verification of Theoretical Assumptions.
Assumption
Theoretical Requirement
Empirical Value
Status
Bounded Rewards (Rmar) Lipschitz Policy (L,))
r(s, a) S R Rmaz < oo Too Te, L 0gl
100.0 0.007 (95th %)
Verified
Verified
Q POLICY INTERPRETATION AND IMPLEMENTATION DETAILS
Q.1 FEATURE IMPORTANCE ANALYSIS
To understand the learned policy me, extracted feature importance weights, As shown in Table 20 the policy prioritizes the fractionality of specific variables over global LP statistics.
Table 20: Top Feature Importance in Learned Policy. The model prioritizes variable fractionality values.
Rank
Importance
Feature Name
Description
0.175
frac_val.2
Fractionality of 2nd most fractional var Total count of fractional variables
2
0.174
num frac vars
0.166
frac.val.7
Fractionality of 7th most fractional var Fractionality of 8th most fractional Fractionality of 4th most fractional var Current LP relaxation objective value
4
0.163
frac_val_8
0.160
frac_val.4
0.160
1p.objective
24

---

Published as a conference paper at ICLR 2026
Q.2 TRAINING HYPERPARAMETERS
Complete hyperparameters used for the PPO agent and GAIL discriminator are provided in Table 21 ensure reproducibility.
Table 21: Hyperparameters for PPO and GAIL Training.
Component
Hyperparameter
Value
Learning Rate
10-4
Discount Factor (r))
0.99
GAE Parameter (A)
0.95
PPO (Policy)
Clipping (e)
0.2
Entropy Coeff
0.01
Batch Size
256
Gen Learning Rate
10-3
Disc Learning Rate
x 10-4
GAIL (Discriminator)
Dise Epochs per Update
3
Network Structure
dmodel 644 h 4
R ADAPTATION TO OTHER MIP COMPONENTS
While this work focuses on cut selection, the MIRACLE framework (GAIL PPO Adaptive Inference) is component-agnostic, We outline how it can be adapted to other MIP solver components:
Branching Variable Selection
State: Node-level features (LP objective, candidate pseudocosts, variable fractionality).
Action: Discrete selection over candidate fractional variables.
Expert Data: Record SCIP's default branching decisions (e.g., relpscost).
Reward: Negative solving time tree size reduction.
Node Selection
State: Tree-level features (Global best bound, open nodes count, depth distribution).
Action: Discrete selection over the set of open nodes (leaves).
Expert Data: Record SCIP's node retrieval sequence (e.g., best-estimate).
In both cases, the core training pipeline remains identical: collecting expert trajectories, training discriminator distinguish expert vs. agent decisions, and optimizing the policy via PPO.
25


Reviews:
[{"review_id": "W9Hbs3nfSE", "reviewer": "Reviewer_anL7", "summary": "This paper proposes MIRACLE, an RL-based framework for adaptive cut selection in mixed-integer programming (MIP). The authors formulate cut selection as a Markov Decision Process (MDP) and employ a PPO-based policy combined with Generative Adversarial Imitation Learning (GAIL) for reward shaping. The approach explicitly optimizes for memory efficiency, achieving dramatic reductions in memory usage (up to 98%) while maintaining comparable or better solving performance compared with SCIP baselines. The authors also provide theoretical analysis (sample complexity, convergence, and memory reduction guarantees) and extensive experiments on SetCover and MIPLIB benchmarks.", "questions": "See weakness", "limitations": "", "rating": 6, "confidence": 4, "soundness": 4, "presentation": 3, "contribution": 4, "strengths": "1. The paper highlights memory efficiency in MILP research. This shift in focus is both original and practically valuable.\n\n2. Combining PPO with GAIL and curriculum learning is a thoughtful design that balances imitation and reinforcement. The adaptive inference strategy further increases practicality.\n\n3.The evaluations across hundreds of MILP instances are detailed and statistically validated, with significant memory and reliability improvements.", "weaknesses": "1. It remains unclear whether MIRACLE generalizes to other MIP components (e.g., branching, node selection) or large-scale industrial solvers beyond SCIP.\n\n2. The paper would benefit from more insight into what the learned policy captures—e.g., are the selected cuts similar to expert strategies or exploiting new patterns?\n\n3. It would be helpful if the authors can provide some training details of RL and analysis the covergence.\n\n4. Although the experiments are extensive, most evaluations focus on SetCover and MIPLIB, leaving out other industrial problem classes. It would help to report on training/inference cost or model sensitivity to solver variants.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "4Jynz7k7yB", "reviewer": "Reviewer_Nw4J", "summary": "The paper addresses the memory explosion caused by thousands of generated cuts in branch-and-cut. Uses GAIL to learn a dense reward function from SCIP expert trajectories, avoiding hand-crafted rewards; Trains a lightweight policy with PPO to select a budget-limited, high-impact subset of cuts; Employs curriculum learning (easy → hard) and an adaptive inference mechanism that sets cut budget B and early-stop thresholds according to predicted instance difficulty.\nOn 150 SetCover and 150 MIPLIB instances MIRACLE attains 98 % peak-memory reduction (46 MB vs 3 GB), raises success rate from 47 % to 100 % under 12 GB RAM limit, and yields 3.78 × mean speed-up over SCIP with large effect sizes and statistical significance.", "questions": "1) How does the small MLP policy scale to instances that generate 50,000+ cuts, and would deeper architectures or graph networks help?\n2) What is the computational cost of collecting the 1000 expert trajectories, and could the method work with fewer demonstrations?\n3) Have you experimented with other policy-gradient algorithms (e.g., TRPO, SAC) and does PPO remain the best choice?", "limitations": "", "rating": 8, "confidence": 4, "soundness": 4, "presentation": 3, "contribution": 4, "strengths": "1) Novel paradigm: demonstrates that intelligent cut selection can reduce memory by > 95 % while improving speed and reliability.\n2) Solid methodology: adversarial reward learning avoids manual engineering; curriculum and adaptive inference remove hyper-parameter tuning at test time.\n3) Strong empirical evidence: 300 instances, statistical tests, ablation studies, and theoretical bounds all align with the claimed benefits.", "weaknesses": "1) Policy network is a small MLP (≈ 17 K parameters); capacity limits for capturing complex cut interactions are not discussed.\n2) Only compares against SCIP default and aggressive modes; no comparison with other recent ML-based cut selectors.\n3) GAIL training requires a large set of expert trajectories (1000 instances); data collection cost is not reported.\n4) Theoretical analysis assumes bounded rewards and Lipschitz policies but does not verify these assumptions hold in the MILP domain.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "yylJwWY4R0", "reviewer": "Reviewer_sN61", "summary": "This paper presents MIRACLE, a reinforcement learning framework that addresses memory inefficiency in Mixed-Integer Programming (MIP) solvers by learning intelligent cut selection policies through Proximal Policy Optimization (PPO) combined with Generative Adversarial Imitation Learning. The framework trains a neural policy that learns from expert solver (SCIP) demonstrations to select high-impact subsets of cutting planes, using a discriminator network to provide dense reward signals and curriculum learning across four difficulty phases. Evaluated on 300 instances spanning SetCover and MIPLIB benchmarks, MIRACLE achieves 86.3% average memory reduction, 3.78× average speedup, and 100% success rate on challenging MIPLIB instances where traditional SCIP fails 47-53% of the time. The method employs adaptive inference that automatically adjusts cut budgets and iteration limits based on problem difficulty classification, with ablation studies showing robust performance across hyperparameter configurations. The framework addresses three key limitations of existing approaches: treating MIP solvers as black boxes, myopic decision-making without environmental modeling, and treating memory efficiency as an afterthought rather than a primary objective.", "questions": "See the weakness part.", "limitations": "", "rating": 4, "confidence": 4, "soundness": 2, "presentation": 2, "contribution": 3, "strengths": "1. The paper follows a logical flow from problem formulation through methodology to evaluation, with helpful visual aids like Figure 1 showing the complete MIRACLE framework and Figure 2 providing comprehensive performance summaries. \n2. The framework achieves a remarkable 98.1% memory reduction on SetCover benchmarks (from 3.03GB to 46MB) and maintains 86.3% average reduction across all 300 test instances, while simultaneously delivering 3.78× average speedup on MIPLIB problems. Most impressively, MIRACLE achieves a 100% success rate on challenging MIPLIB instances where traditional SCIP fails 47-53% of the time, demonstrating that memory efficiency directly translates to improved solver reliability.\n3. The evaluation spans 300 instances from established benchmarks, including SetCover and diverse MIPLIB datasets across three difficulty levels, with the largest instances containing up to 1000 operations. The method demonstrates consistent performance across fundamentally different problem types and scales, with detailed ablation studies showing robustness across hyperparameter configurations in real-world deployment scenarios.", "weaknesses": "In general, this paper show very impressive results on memory reductions and even speed up. However, I have the following concerns which may largely impact the paper’s significance.\n\nWhile the paper demonstrates impressive results under a 12GB memory limit, it lacks compelling evidence for why this specific constraint is realistic or necessary in modern computing environments where servers often have 64-256GB RAM. The authors don't provide concrete examples of deployment scenarios (edge computing, embedded systems, or cloud resource billing) where such strict memory limits are critical, making the 12GB restriction appear artificially constraining rather than addressing a well-motivated practical need.\n\nThe paper only compares against SCIP-default and SCIP-aggressive, omitting recent learning-based cut selection methods from the ML4CO literature that likely also achieve memory reductions as a byproduct of selective cut management (e.g., methods that use GNNs for cut ranking or reinforcement learning for adaptive cut generation). More critically, the speed comparisons in Table 3 are conducted under the artificial 12GB memory limit which causes SCIP to fail on 47-53% of instances. This fundamentally biases the evaluation since traditional solvers are designed to trade memory for speed and would perform differently without this constraint. The paper would greatly benefit from: (a) performance comparisons both with and without memory limits to fairly assess the speed-memory tradeoff, (b) inclusion of recent ML-based cut selection baselines, and (c) analysis of how much memory reduction other selective cut approaches naturally achieve without explicitly optimizing for it.\n\nThe evaluation is limited to SetCover and MIPLIB instances, missing other important combinatorial optimization problems such as Maximum Independent Set, and Facility Location problems that are equally relevant in practice and used in previous works. This narrow scope makes it difficult to assess whether MIRACLE's approach generalizes beyond the two tested problem types.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "02tXBeKVoz", "reviewer": "Reviewer_bhtG", "summary": "This paper presents an intelligent cut selection framework for Mixed-Integer Programming (MIP) solvers that drastically reduces peak memory usage by 98.1% while maintaining competitive performance. The method employs Proximal Policy Optimization (PPO) within an adversarial imitation learning setup to mimic an expert solver’s decisions, featuring a curriculum-trained cut-selection policy and adaptive inference for dynamic computational budgeting. Evaluated on SetCover and diverse MIPLIB instances, it achieves consistent speedups and a 100% success rate on problems where SCIP fails 47–53% of the time, demonstrating strong potential for deployment in memory-constrained settings.", "questions": "- The policy ultimately imitates SCIP’s cut selection strategy—so why does it achieve noticeable speedups, especially in solving time? Is the gain due to fewer cuts, better timing, reduced overhead, or another factor?  \n- What data was used for training? How were the 300 test instances selected, particularly the 150 from MIPLIB? Given that MIPLIB contains far more instances, what was the selection criterion (e.g., difficulty, size, feasibility)?  \n- In Table 1, what does “early stop” refer to, and what is the meaning of “Max Iterations”?  \n- How were the 600-second time limit and 12 GB memory cap determined? Many MIPLIB instances require significantly longer to solve—could this experimental setup bias results toward easier cases?  \n- Why introduce a custom “success rate” metric instead of using widely adopted, more direct measures like primal gap or final objective value?  \n- Could the authors clarify: on what data is the discriminator trained, what is its training workflow, and how does it coordinate with the RL training? Understanding the full pipeline is essential for evaluating the method’s soundness and reproducibility.  \n- Why choose SCIP’s cut selection as the expert policy? Given that it relies on heuristic rules, are there higher-quality expert strategies (e.g., from stronger solvers or human-designed oracles) that could further improve performance?  \n- What is the design rationale behind the curriculum learning scheme? What performance gain does it provide, and could an ablation study quantify its contribution?\n\nI am eager to participate in the discussion phase and look forward to a thorough and objective assessment of this work based on the authors’ responses.", "limitations": "", "rating": 4, "confidence": 5, "soundness": 2, "presentation": 2, "contribution": 2, "strengths": "- Cut selection is indeed a critical research direction, and improving it can substantially boost solver efficiency.  \n- The focus on reducing peak memory consumption is particularly interesting and, to the best of my knowledge, has been rarely emphasized in prior literature—making it a compelling practical attempt.  \n- The method shows stability across different hyperparameter configurations, which is encouraging and suggests the system may be close to deployment-ready.  \n- The use of adversarial imitation within the reinforcement learning framework is interesting and offers a fresh perspective on reward design, with detailed theoretical analysis, which, in my view, constitutes a meaningful contribution.", "weaknesses": "- The paper overall feels somewhat rushed and leaves several important aspects underdeveloped.  \n- The core motivation—why reducing peak memory consumption is essential—is not sufficiently justified. As a central claim of the paper, this requires clearer explanation: in what real-world scenarios does memory become a bottleneck, and which components of the proposed method specifically target this issue?  \n- The paper completely omits a related work section and fails to acknowledge or compare against several highly relevant prior works on learning-based cut selection, including:  \n  [1] Wang Z, Li X, Wang J, et al. Learning Cut Selection for Mixed-Integer Linear Programming via Hierarchical Sequence Model. ICLR 2023.  \n  [2] Paulus M B, Zarpellon G, Krause A, et al. Learning to cut by looking ahead: Cutting plane selection via imitation learning. ICML 2022.  \n  [3] Tang Y, Agrawal S, Faenza Y. Reinforcement learning for integer programming: Learning to cut. ICML 2020.  \n  Not only are these works not cited, but no experimental comparison is provided. This omission is significant and, in my view, unfair to prior contributions.  \n- Despite extensive mathematical formalism, many crucial implementation details remain unclear:  \n  1) It is not specified on what data the discriminator network is trained, what its training procedure is, or how it integrates with the PPO-based RL loop—making the overall training pipeline ambiguous.  \n  2) The choice of SetCover and MIPLIB as testbeds lacks justification; other standard MIP benchmarks (e.g., MaxCut, TSP) exist, and the selection criteria for the 300 test instances are unexplained.  \n  3) While Appendix Algorithm 1 offers partial clarification, key questions persist—for example, where the Phase 1 policy comes from and whether Phases 1–3 are trained sequentially.  \n  4) The heavy notation would greatly benefit from a summary table or diagram; as is, the exposition is unnecessarily difficult to follow.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)