Paper deep dive
TACIT: Optimization Models that Learn from Their Mistakes
Maxime Bouscary, Marco Molinaro, Sirui Li, Saurabh Amin, Ishai Menache, Konstantina Mellou
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 93%
Last extracted: 10/1/2026, 8:17:26 AM
Summary
The paper introduces TACIT, a framework for automatically repairing misspecified optimization formulations using historical data of past solutions and user overrides. It combines Large Language Models (LLMs) for structural reasoning and proposal with optimization techniques for numerical calibration and validation. TACIT employs two paradigms: top-down, where LLMs propose structural repairs (new constraints/variables) calibrated by optimization, and bottom-up, where optimization infers cuts from observed decisions which LLMs contextualize into interpretable constraints. Evaluated on 38 scenarios, TACIT repairs 78.9% of misspecifications, outperforming baselines.
Entities (7)
Relation Signals (6)
Maxime Bouscary → affiliatedwith → Massachusetts Institute of Technology
confidence 95% · Affiliation: Massachusetts Institute of Technology, Cambridge, MA, USA
Marco Molinaro → affiliatedwith → Microsoft Research
confidence 95% · Affiliation: Microsoft Research, Redmond, WA, USA
TACIT → appliesto → Mixed-Integer Linear Programs
confidence 95% · We consider mixed-integer linear programs (MILPs)... We evaluate our approach on 38 misspecification scenarios spanning nine classes of optimization problems
TACIT → uses → LLM
confidence 95% · Our central idea is to combine the reasoning capabilities and prior knowledge of LLMs with the formal grounding provided by optimization.
TACIT → demonstratedon → Vehicle Routing Problem
confidence 90% · Example 1 (Vehicle routing problem (VRP))... In this example, the initial formulation M0 omits this penalty...
TACIT → outperforms → Inverse Optimization
confidence 90% · Traditional approaches such as inverse optimization and constraint learning tend to overfit sparse data... TACIT can repair 78.9% of them (vs. 60.5% for the best baseline).
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Real-world optimization problems are difficult to model accurately because many objectives and constraints reside in domain experts' tacit knowledge, making them hard to formalize. As a result, optimization models often contain miscalibrated objectives, missing constraints, or omitted decision variables, leading to solutions that fail to reflect operational realities. We address this challenge by automatically repairing misspecified formulations using historical data consisting of past solutions and subsequent user overrides. Traditional approaches such as inverse optimization and constraint learning tend to overfit sparse data and produce complex formulations. Our central idea is to combine the reasoning capabilities and prior knowledge of LLMs with the formal grounding provided by optimization. We realize this idea through two complementary paradigms. Top-down, an LLM proposes structural repairs, including new constraints and variables, whose numerical parameters are calibrated and validated through optimization. Bottom-up, optimization infers cuts from observed decisions, which the LLM contextualizes into interpretable, generalizable modeling constraints. We evaluate our approach on 38 misspecification scenarios spanning nine classes of optimization problems, several drawn from real-world applications, and show that TACIT can repair 78.9% of them (vs. 60.5% for the best baseline).
Tags
Links
- Source: https://arxiv.org/abs/2609.38434v1
- Canonical: https://arxiv.org/abs/2609.38434v1
Trouble viewing inline? Open PDF directly →
Full Text
89,601 characters extracted from source content.
Expand or collapse full text
TACIT: Optimization Models that Learn from Their Mistakes Maxime Bouscary †thanks: This work was performed during an internship at Microsoft Research. Affiliation: Massachusetts Institute of Technology, Cambridge, MA, USA Email: mbscry@mit.edu Marco Molinaro Affiliation: Microsoft Research, Redmond, WA, USA Email: amins@mit.edu Sirui Li Affiliation: Microsoft Research, Redmond, WA, USA Email: mmolinaro@microsoft.com Saurabh Amin Ishai Menache Konstantina Mellou Affiliation: Massachusetts Institute of Technology, Cambridge, MA, USA Affiliation: Microsoft Research, Redmond, WA, USA Email: siruili@microsoft.com Email: ishai@microsoft.com Email: kmellou@microsoft.com Abstract Real-world optimization problems are difficult to model accurately because many objectives and constraints reside in domain experts’ tacit knowledge, making them hard to formalize. As a result, optimization models often contain miscalibrated objectives, missing constraints, or omitted decision variables, leading to solutions that fail to reflect operational realities. We address this challenge by automatically repairing misspecified formulations using historical data consisting of past solutions and subsequent user overrides. Traditional approaches such as inverse optimization and constraint learning tend to overfit sparse data and produce complex formulations. Our central idea is to combine the reasoning capabilities and prior knowledge of LLMs with the formal grounding provided by optimization. We realize this idea through two complementary paradigms. Top-down, an LLM proposes structural repairs, including new constraints and variables, whose numerical parameters are calibrated and validated through optimization. Bottom-up, optimization infers cuts from observed decisions, which the LLM contextualizes into interpretable, generalizable modeling constraints. We evaluate our approach on 38 misspecification scenarios spanning nine classes of optimization problems, several drawn from real-world applications, and show that TACIT can repair 78.9% of them (vs. 60.5% for the best baseline). 1 Introduction Mathematical optimization is a powerful tool for decision-making, enabling organizations to make complex decisions at a scale and speed that would be difficult to achieve manually. As a result, it plays a central role in automating decision processes across applications such as supply chain and logistics, scheduling, resource allocation, and infrastructure planning. However, an optimization system is only as good as the formulation on which it is built. Constructing such a formulation requires translating a real-world decision problem into decision variables, constraints, and objectives that faithfully capture how decisions should be made in practice. This translation is inherently challenging. It typically requires close collaboration between domain experts, who understand the operational requirements and preferences governing decisions, and optimization experts, who encode this knowledge into a mathematical model. Much of this knowledge, however, is tacit and may not be fully articulated during model development. Consequently, optimization formulations can contain misaligned objectives, missing constraints, or omitted variables, producing solutions that fail to reflect operational realities (Baxi et al., 2026). Large Language Models (LLMs) are increasingly being used to automate parts of the formulation process by translating natural-language problem descriptions into mathematical optimization models (AhmadiTeshnizi et al., 2024; Astorga et al., 2024; Zhang et al., 2024). While recent advances have substantially improved formulation accuracy, they do not eliminate the fundamental challenge of specifying the right decision problem. Requirements absent from the problem description cannot readily be reflected in the resulting formulation, and LLMs may introduce additional formulation errors of their own. Thus, LLM-generated formulations may also be incomplete or misaligned with the decisions users intend to make. When misaligned optimization systems are deployed in practice, deficiencies in the underlying formulation become visible through their decisions. Recommendations that violate implicit operational requirements or fail to capture user preferences may be rejected, manually overridden, or repeatedly adjusted through tedious processes. Addressing such failures thus often requires costly iterations between domain and optimization experts to diagnose the source of the mismatch and revise the formulation. Yet, these interactions also generate valuable information: rejected recommendations and user corrections provide signals about which aspects of the formulation are incomplete or misaligned. This motivates our central question: Can we recover the formulation that governs users’ decisions from their corrections, as an explicit and interpretable repair of the deployed one? To illustrate the difficulty, consider a toy example with a manufacturer choosing the number of motors (x) to produce and machines (y) to assemble, where each machine requires one motor. Suppose the formulation mistakenly omits this dependency and captures only production capacity and handling constraints: max2x+5y:2x+3y≤10,x+y≤4,x,y∈ℤ≥0 \2x+5y:2x+3y≤ 10,\;x+y≤ 4,\;x,y _≥ 0 \. Its optimal solution, (0,3)(0,3), assembles three machines without producing any motors. The user corrects it to (2,2)(2,2), which is optimal under the intended constraint x≥yx≥ y. However, this correction does not uniquely reveal the missing constraint: many constraints could make (2,2)(2,2) optimal, while a similar result could be achieved by just changing the objective coefficients. Recovering x≥yx≥ y thus requires understanding the semantic relationship between the variables, highlighting the difficulty of repairing optimization models from solution feedback alone. In practice, users typically provide multiple feedback points as they repeatedly solve instances of the same underlying formulation, but this challenge grows significantly for real-world formulations with a substantial number of variables and constraints, often spanning distinct semantic families and different aspects of the modeled system. More fundamentally, the formulation itself may be incomplete: entire variables may be missing, including auxiliary variables used to represent nonlinear objectives or logical relationships (see Example 1). Repair may therefore require recovering not only constraints, but missing pieces of the modeling structure itself. This toy example exposes three broader challenges that make formulation repair fundamentally hard: • Indirect feedback. In practice, users such as supply chain planners or business operators typically focus on correcting the proposed solution rather than diagnosing the underlying model error. • Non-identifiability. A corrected solution rarely pins down the intended model: the same feedback may be explained by different constraints, objectives, or structural changes, as in the example above. With few corrections, local fixes can explain without capturing the underlying rule. • Interpretability. A repair should not merely reproduce observed decisions through an unnatural or unnecessarily complex formulation: it should have a clear real-world interpretation that users can inspect and validate. Recent work highlights the challenges practitioners face in interpreting and modifying optimization models, as well as the broader importance of aligning algorithmic systems with human judgment and organizational objectives (Chen et al., 2026; Caro et al., 2026). Our contribution. We introduce TACIT (Templates And Cuts for Interpretable Transformations), an end-to-end framework for automatically repairing optimization formulations from feedback. We cast repair as a search over modifications of the original formulation: adding or changing constraints, variables, and objective terms. This space is vast and underdetermined: many formulations can be consistent with any finite set of corrections, but few are meaningful to a modeler. Our central idea is to combine the reasoning capabilities and prior knowledge of LLMs with the formal grounding provided by optimization. We realize this idea through two complementary paradigms that run within a single search loop. Bottom-up, optimization derives cuts that separate rejected solutions from accepted ones, and an LLM agent interprets, refines, and generalizes these cuts into meaningful modeling rules. Top-down, an LLM agent identifies a potentially missing modeling component and expresses it as a template, possibly introducing new variables, constraints, or unspecified parameters, which optimization then specifies from the feedback. This hybrid architecture provides several advantages: 1. Broad coverage of misspecifications. Our framework supports a substantially broader class of repairs than local changes to coefficients or individual constraints, recovering missing, extraneous, or miscalibrated components in the objective, constraints, and variables. A single repair can introduce auxiliary variables, add or remove constraints, and modify the objective jointly. 2. Domain generality. The framework is not tailored to a specific application domain (e.g., transportation, scheduling) and applies across structurally diverse optimization models. 3. No human in the loop. The framework operates from sparse, offline signals, namely user-corrected solutions, without querying users or requiring them to diagnose the model error. 4. Interpretability and generalization. By searching over semantically meaningful modeling changes, the framework promotes interpretability while leveraging limited feedback to recover modeling rules that generalize beyond observed data. Finally, we construct a comprehensive benchmark of 38 misspecification scenarios spanning nine classes of optimization problems, including several real-world applications, with errors involving constraints, variables, parameters, and objective components. Across these settings, TACIT can recover the ground-truth formulation, up to decision equivalence, in 78.9% of the scenarios from limited user feedback, against 60.5% for the best baseline. The recovered formulations generalize to unseen instances, and our ablations show that combining LLM reasoning with optimization is critical. At the same time, both top-down and bottom-up inference improve repair performance independently, but their combination achieves the best overall performance. Overall, our experiments show that sparse solution feedback can be sufficient to repair complex formulation misspecifications without requiring users to diagnose the formulation themselves. 2 Related Work Data-driven model customization and preference modeling. The closest works to ours (Hewitt and Frejinger, 2020; Bayani et al., 2024; Abdellaoui et al., 2026) correct optimization models from prescribed and implemented solutions by learning a function that models directly how users modify the solutions. These approaches range from affine mappings (Hewitt and Frejinger, 2020) to regression and decision trees (Bayani et al., 2024), and richer predictors for routing and scheduling (Abdellaoui et al., 2026). Related work learns user preferences within an optimization problem (Maragno et al., 2025); see also Fajemisin et al. (2021). There, an ML model modeling user behavior or preference is embedded within the optimization formulation and is trained based on the optimization outcomes. While these data-driven customization methods can substantially improve decisions, the learned behavioral or preference models are encoded within the formulation using additional variables and constraints that do not possess real-world meaning. In contrast, we recover an explicit, corrected formulation that can be inspected and validated by humans. Moreover, some complex formulation errors cannot be corrected by such learned-function embeddings, as shown in Theorem 1 (Appendix A.1); our framework can recover the appropriate corrections even in these complex cases. Inverse optimization and learning optimization models. Inverse optimization estimates unknown model parameters from observed decisions, including under multiple or noisy observations and imperfect information (Chan et al., 2025; Moghaddass and Terekhov, 2021; Aswani et al., 2018; Mohajerin Esfahani et al., 2018; Bulut and Ralphs, 2021). Recent methods also jointly learn objectives and feasible regions of LPs or MILPs from contextual examples (Tan et al., 2020; Kumar et al., 2021; Ren et al., 2025; Kitaoka, 2025). This literature motivates our numerical calibration components and highlights the identifiability challenges of decision-only supervision. Moreover, our setting additionally requires recovering the semantic and structural content of a misspecified formulation. In addition, these methods cannot naturally capture more complex structural corrections that require introducing new variables and coordinating them with new constraints or objective terms. Our framework addresses both limitations by using LLMs to inject semantic knowledge into the repair process and to propose structural changes involving previously absent variables. Language models for optimization modeling and repair. LLMs have been used to formulate optimization models from natural-language specifications and diagnose or repair them using solver feedback and domain-specific checks (AhmadiTeshnizi et al., 2024; Xiao et al., 2024; Astorga et al., 2024; Zhang et al., 2024; Thind et al., 2025; Jiang et al., 2025; Chen et al., 2024; Ao et al., 2026a; Ao et al., 2026b); see Xiao et al. (2025) for a recent survey. This literature is complementary to our setting: autoformulation methods assume intended requirements are expressed in the specification, while diagnostic repair relies on explicit specifications, infeasibility, or predefined checks. We instead address requirements that are missing from the formulation and its specification, inferring them from downstream behavioral evidence and combining LLM semantic priors with optimization-based validation. 3 Problem definition Core concepts. An instance is described by a data vector d (e.g., demands, capacities, availabilities), whose dimension may vary across instances. We consider mixed-integer linear programs (MILPs), with linear programs (LPs) as a special case. A formulation is a pair ℳ=(c,)M=(c,X) mapping instance data d to an optimization problem ℳ(d)M(d): minc(d)⊤y c(d) y s.t. y∈(d)y (d), where c(d)c(d) is the vector of objective coefficients and (d)X(d) the feasibility set, defined by linear constraints and, when applicable, integrality requirements. We use (d,ℳ)S(d;M) to denote its set of optimal solutions. An initial formulation ℳ0=(c0,0)M_0=(c_0,X_0) is given but may not fully capture the underlying decision problem. There is an unknown target formulation ℳ⋆=(c⋆,⋆)M =(c ,X ) that is the ground truth that governs the decisions actually taken. The two may differ in the objective (missing terms or incorrect weights), constraints (missing, miscalibrated, or extraneous constraints), variables (e.g., auxiliary variables present only in ℳ⋆M ), or any combination thereof. Example 1 (Vehicle routing problem (VRP)). A company operates a fleet ℒL of vehicles and must serve a set of customers C, with dijd_ij denoting the distance between customers i and j. Let variable xijℓx_ij indicate whether vehicle ℓ visits customer j immediately after customer i. The company seeks to minimize total distance plus a penalty for routes that exceed D miles. In this example, the initial formulation ℳ0M_0 omits this penalty, which appears in the target formulation ℳ⋆M (in blue): ℳ0:minx _0: _x ∑ℓ∈ℒ∑i,j∈Cdijxijℓ _ _i,j∈ Cd_ijx_ij s.t. .t. x∈VRP. x _VRP. ℳ⋆:minx,z : _x,z ∑ℓ∈ℒ∑i,j∈Cdijxijℓ+λ∑ℓ∈ℒzℓ _ _i,j∈ Cd_ijx_ij + [rgb]0,0,1λ _ z_ s.t. .t. x∈VRP, x _VRP, ∑i,j∈Cdijxijℓ≤D+Mzℓ, [rgb]0,0,1 _i,j∈ Cd_ijx_ij ≤ D+Mz_ , ∀ℓ∈ℒ [rgb]0,0,1 ∀ zℓ∈0,1, [rgb]0,0,1 z_ ∈\0,1\, ∀ℓ∈ℒ, [rgb]0,0,1 ∀ , VRPX_VRP denotes the standard VRP constraints. Repairing ℳ0M_0 requires coordinated changes: adding auxiliary variables, linking constraints, a new objective term, and estimating its coefficient λ. We refer to the variables of the initial formulation ℳ0M_0 as primary variables: they encode the actionable decisions made and reported by practitioners. In Example 1, xijℓx_ij are primary, while the auxiliary variables zℓz_ introduced by ℳ⋆M are not. Any additional variables introduced by ℳ⋆M are called auxiliary variables. Only the primary variables of ℳ⋆M are observed in the user feedback. Let Π0 _0 be the projection that restricts a solution to the primary variables. A feasible lifting of x under ℳM is any solution y∈(d)y (d) satisfying Π0(y)=x _0(y)=x. Observed data. Instances are drawn from an unknown distribution P over triples (d,x0,x⋆)(d,x^0,x ), where x0∈(d,ℳ0)x^0 (d;M_0) is the initial solution and x⋆∈Π0((d,ℳ⋆))x ∈ _0(S(d;M )) the target solution, the projection onto the primary variables of an optimal solution of ℳ⋆(d)M (d). We observe a sample =(di,xi0,xi⋆):i∈ℐ∼P|ℐ|D= \ (d_i,x_i^0,x_i ):i \ P^|I|. Optimality of the targets is a standard assumption of inverse optimization (Chan et al., 2025; Besbes et al., 2025): we use it to describe the problem and our methodology and relax it in some of our experiments. We further posit that whenever xi0≠xi⋆x_i^0≠ x_i , the target is strictly preferred, that is, every lifting of xi0x_i^0 is infeasible or strictly suboptimal under ℳ⋆M . This reflects practice, where the initial solution is the default and practitioners depart from it only when an alternative is strictly better. Separation loss. Our goal is to find a formulation ℳM that best explains the observed data D. We formalize this through separability: ℳM separates D if, for every instance i with xi0≠xi⋆x_i^0≠ x_i , xi⋆∈Π0((di,ℳ))x_i ∈ _0\! (S(d_i;M) ) and xi0∉Π0((di,ℳ))x_i^0∉ _0\! (S(d_i;M) ). That is, the target solution is feasible and optimal under ℳM, whereas the initial solution is not. By the assumptions above, ℳ⋆M separates D. To quantify the degree of separation achieved by a candidate formulation ℳ=(c,)M=(c,X), we measure the feasibility and optimality of a solution x on instance i through its relative optimality gap γi(x)≜Zi(x)−Ziopt|Ziopt|, _i(x) Z_i(x)-Z_i^opt|Z_i^opt|, where Ziopt=minc(di)⊤y:y∈(di)Z_i^opt= \c(d_i) y:y (d_i)\ and Zi(x)=minc(di)⊤y:y∈(di),Π0(y)=xZ_i(x)= \c(d_i) y:y (d_i), _0(y)=x\ denote, respectively, the optimal objective value of ℳ(di)M(d_i) and the best objective value among feasible liftings of x.11 1 When Ziopt=0Z_i^opt=0, we add a small positive constant to the denominator, and if x does not admit a feasible lifting under ℳ(di)M(d_i) we define γi(x)=1 _i(x)=1. By construction, γi(x)=0 _i(x)=0 if and only if x∈Π0((di,ℳ))x∈ _0(S(d_i;M)). Given tolerances 0≤δ≤Δ<10≤δ≤ <1, we define the separation loss: ℒ(ℳ,)≜1−1|ℐ|∑i∈ℐri(ℳ),ri(ℳ)≜γi(xi⋆)≤Δ⋅γi(xi0)≥γi(xi⋆)+δif xi0≠xi⋆γi(xi⋆)≤Δotherwise.L(M;D) 1- 1|I| _i r_i(M),\;r_i(M) cases 1_ \ _i(x_i )≤ \· 1_ \ _i(x_i^0)≥ _i(x_i )+δ \&if x_i^0≠ x_i \\ 1_ \ _i(x_i )≤ \&otherwise. cases (1) Here, Δ bounds the relative optimality gap of the observed target solutions, while δ is the minimum gap difference separating the initial solution from the target. Thus, ri(ℳ)=1r_i(M)=1 if ℳM makes xi⋆x_i near-optimal within tolerance Δ and, when xi0≠xi⋆x_i^0≠ x_i , prefers xi⋆x_i to xi0x_i^0 by at least δ. In this case, we say that ℳM separates instance i. The loss ℒ(ℳ,)∈[0,1]L(M;D)∈[0,1] is thus the fraction of instances that ℳM fails to separate, and ℒ(ℳ,)=0L(M;D)=0 if and only if ℳM separates D. We frame the formulation correction problem as finding a formulation minimizing the expected separation loss: minℳ∼P[ℒ(ℳ,)] _M\;E_D P [L(M;D) ]. Since P is unknown, we minimize ℒ(ℳ,)L(M;D) on the observed dataset D and assess generalization on held-out instances. As there can be multiple equivalent formulations differing widely in size and readability, our method additionally aims for a parsimonious transformation of ℳ0M_0 that remains interpretable for practitioners maintaining ℳ0M_0. 4 Methodology Figure 1: TACIT framework overview. Our framework is illustrated in Figure 1. We maintain an incumbent formulation ℳ=(c,)M=(c,X), initialized by removing from ℳ0M_0 any constraints that render a target solution infeasible. We then iteratively generate, evaluate, and incorporate candidate transformations. Candidates are generated via two complementary paradigms that combine optimization and LLM agents in opposite directions. In the bottom-up paradigm, optimization finds linear inequalities separating solutions of the incumbent formulation from the targets, which an LLM agent contextualizes and extrapolates into meaningful constraints or constraint families. In the top-down paradigm, an LLM agent proposes a transformation template whose learnable terms are calibrated through optimization. Candidates are evaluated using the separation loss (1), before and after objective calibration, and an improving candidate becomes the new incumbent. These steps are applied sequentially and repeated until the computational budget is exhausted; Algorithm C.1 gives the full procedure. Finding an improved formulation presents several challenges: (i) handling multiple and general formulation errors; (i) navigating the vast space of possible formulations; (i) constructing inequalities and objectives that apply across different instance sizes; (iv) producing interpretable transformations; and (v) generalizing to unseen instances under limited data. We next detail the formulation transformations in our system and how they address these challenges. 4.1 Bottom-up: cuts and contextualization Cut search. A cut for formulation ℳM is a linear inequality satisfied by every target solution xi⋆x_i but excludes at least one of the projected optimal solutions x^i x_i of ℳM. We seek to add cuts to the current incumbent formulation ℳM that is not yet fully correct. Challenges (i) and (i) immediately appear. To be deployed across instances, a cut has to be a function of the instance data d, which leads to a large search space. We restrict this space by considering cuts a(d)⊤x≤b(d)a(d) x≤ b(d) where the components a(d)a(d) and b(d)b(d) are affine functions of the data. Moreover, to handle varying instance sizes (e.g., VRP with different number of customers), we employ family-level weights to define the cuts: each coefficient has the form a(d)k=αt(k)⊤ϕk(d)a(d)_k= _t(k) _k(d), where ϕk(d) _k(d) is the data associated with variable k and αt(k) _t(k) is the weight vector (to be estimated) for its the family t(k)t(k) of this variable; similarly b(d)=β⊤ϕ0(d)b(d)=β _0(d), where ϕ0(d) _0(d) represents data not associated to a particular variable family and β are the weights to be estimated. More details about this concept can be found in Appendix E.1. We infer α and β through a MILP (see Appendix E.1) that maximizes the cut quality score maxα,β,z,η1|ℐ|∑i∈ℐzi−ρ(‖α‖0+‖β‖0)+εη, _α,β,z,η 1|I| _i z_i-ρ (\|α\|_0+\|β\|_0 )+ η, (2) subject to validity for every xi⋆x_i , where ziz_i indicates whether x^i x_i violates the cut by at least a margin η≥η¯>0η≥ η>0. The score therefore rewards cuts that eliminate a large fraction of the solutions from formulation ℳM, favors simple and sparse structure, and, through the small term εη η with 0<ε≪10< 1, breaks ties in favor of stronger separation. Sparsity regularization limits overfitting, promoting cut generalization to unseen instances, and also improves interpretability, since meaningful combinatorial constraints often involve only few variables and instance features (Challenges (iv)-(v)). We sweep the parameter ρ, generating cuts from the sparsest nonempty solution to the unregularized one, and evaluate them by separation loss. These candidates are then passed to the cut contextualization step for polishing and extrapolation. Cuts contextualization. The cut-search procedure identifies sparse numerical structures that explain the observed corrections, but the resulting coefficients need not directly reveal the underlying modeling intent. We therefore invoke an LLM agent to contextualize each discovered cut using the full formulation ℳM. The agent first polishes the cut by proposing semantically plausible transformations, such as rounding coefficients, removing negligible terms, and introducing contextually relevant terms. For example, the search may return the cut 0.98xi+1.03xj−1.01yk≤0.970.98x_i+1.03x_j-1.01y_k≤ 0.97, while the underlying combinatorial structure is more naturally expressed as xi+xj−yk≤1x_i+x_j-y_k≤ 1. Thus, the search identifies the relevant geometry, while the LLM uses the formulation context to recover a cleaner symbolic representation, which is crucial for interpretability. Importantly, the LLM does not unilaterally select the repair: it proposes a collection of candidate transformations, which are evaluated using the separation loss (1), and the lowest-loss variant is retained. The agent then extrapolates the accumulated cuts into indexed constraint families. For instance, x3,7≤y3x_3,7≤ y_3 may suggest the family xij≤yi,∀i,jx_ij≤ y_i,\ ∀ i,j. Such families are ubiquitous (e.g., Example 1) and can encode many individual constraints. With limited data (Challenge (v)), observed corrections may reveal only a few members of the underlying family, making extrapolation important for recovering its broader structure. Table B.5 provides cut contextualization examples from our experiments. 4.2 Top-down: templates and calibration Some target formulations introduce additional variables and therefore cannot be recovered through cuts alone (Theorem 1). The top-down paradigm addresses this limitation by having an LLM agent propose a template for the transformation, potentially introducing auxiliary variables, modifying variable domains, and adding constraint families with unspecified parameters. Optimization then calibrates these parameters to preserve target solutions while maximally separating unwanted ones. Template generation. Rather than asking the LLM to produce a fully specified repair, we use it to propose a structural hypothesis for how the formulation should change. The agent receives the incumbent formulation ℳM, constraints removed during preprocessing, and samples of mismatched pairs (x^i,xi⋆)( x_i,x_i ), where x^i x_i is a projected optimal solution of ℳM, i.e., x^i=Π0(y^i) x_i= _0( y_i) for y^i∈(di,ℳ) y_i (d_i;M). It proposes a template τ specifying what should change, while leaving its learnable parameters unspecified. This separation is important: the agent identifies a semantically meaningful modeling mechanism, while the subsequent calibration step determines whether and how it can be instantiated without excluding the observed targets. Table B.6 provides template examples from our experiments. Formally, a template τ specifies (i) new auxiliary variables z with domain Zτ(d)Z_τ(d); (i) constraints gj(y,z,w,d)≤0g_j(y,z,w;d)≤ 0, j∈Jτ(d)j∈ J_τ(d), parameterized by weights w to be calibrated; and (i) a possibly modified domain τ(d)Y_τ(d) for the existing variables y. Dependence on d allows templates to generalize across instance sizes. The functions gjg_j are bi-affine in (y,z)(y,z) and w, yielding the updated feasible set τ(d;w)=(y,z):y∈(d),z∈Zτ(d),gj(y,z,w;d)≤0,∀j∈Jτ(d).X_τ(d;w)= \(y,z):y (d),\;z∈ Z_τ(d),\;g_j(y,z,w;d)≤ 0,\;∀ j∈ J_τ(d) \. (3) A template does not change the objective function and assigns zero objective coefficients to new variables; their contribution is determined separately by the objective-calibration step in Section 4.3. For example, in the VRP setting of Example 1, the missing long-route penalty cannot be recovered through cuts over the existing variables alone. A template can introduce binary variables zℓz_ , ℓ∈ℒ , indicating long routes and constraints gℓ(x,z,w,d)≤0g_ (x,z,w;d)≤ 0, ℓ∈ℒ , linking them to route lengths. Calibration may instantiate these as ∑i,j∈Cdijxijℓ≤D+Mzℓ _i,j∈ Cd_ijx_ij ≤ D+Mz_ . Thus, the LLM agent identifies the missing modeling structure, while optimization determines its numerical parameters, enabling repairs involving multiple connected modeling changes (Challenge (i)). Template completion. We calibrate the template weights w to preserve all observed targets while maximally separating the optimal solutions of the current formulation ℳM. Preservation requires each xi⋆x_i to admit a lifting yi⋆y_i into the non-primary variables of ℳM and an assignment of the new variables zi⋆z_i such that (yi⋆,zi⋆)(y_i ,z_i ) belongs to the new feasible set τ(di,w)X_τ(d_i;w). We therefore solve an optimization problem with max-min structure to jointly calibrate the template parameters w against the best completions z^i z_i of the new variables. We solve this problem via constraint generation and discard any template where no weights allow every target to be feasibly lifted; see Appendix E.2. 4.3 Objective calibration Cuts and templates modify the feasible set, but misspecification may also lie in the objective. Moreover, auxiliary variables introduced by templates may matter via their cost. Thus, every candidate formulation ℳ=(c,)M=(c,X) undergoes objective calibration, keeping X fixed while learning c. Calibration balances two goals: (i) each target xi⋆x_i should admit a feasible lifting yi⋆y_i that is nearly optimal under the calibrated objective, allowing some suboptimality to accommodate potentially suboptimal target solutions in practice, (i) the lifted target yi⋆y_i should outperform the current model solution y^i y_i by as large a margin as possible. Appendix E.3 provides the resulting optimization problem. 5 Numerical Results 5.1 Experimental Setup Dataset. We introduce a benchmark of 38 scenarios spanning nine classes of LPs and MILPs. The benchmark combines classical optimization problems with realistic applications, including scenarios motivated by resource allocation in hyperscalers. The scenarios cover a broad range of formulation errors along two dimensions: the affected component (objective, constraints, variables, domains) and nature of the error (extraneous, missing, miscalibrated, local, global). Many scenarios deliberately combine multiple forms of misspecification. Each scenario specifies an initial formulation ℳ0M_0 and a target formulation ℳ⋆M . Appendix D gives them in full and Table D.1 summarizes the taxonomy. We will release the benchmark for reproducibility and future research on formulation repair. Baselines and protocol. We compare our framework against (i) the initial formulation, (i) the data-driven methods of Hewitt and Frejinger (2020); Bayani et al. (2024), which we denote AOP, and (i) an LLM-only baseline that generates the complete optimization model as gurobipy code from the initial code and pairs of model and target solutions. For each scenario, every method is run 5 times using N=128N=128 training instances and evaluated on a disjoint set of 256 test instances. Metrics. We evaluate the final incumbent formulation ℳM on both training and test instances. On the training set, we report the separation loss ℒL and the separation rate, defined as the fraction of runs with ℒ=0L=0. On the test set, we report four metrics. The feasibility rate is the fraction of test instances for which the solution produced by ℳM is feasible under ℳ⋆M . The optimality rate is the fraction for which that solution is feasible and within 1%1\% of the optimal value under ℳ⋆M in relative gap. The recovery rate is the proportion of scenarios for which this optimality criterion holds on all 256 test instances. These metrics are averaged over the 5 runs of each method. Finally, the recoverable rate is the proportion of scenarios for which at least one of the 5 runs attains recovery, capturing the fraction of scenarios that are amenable to formulation repair by TACIT. 5.2 Results We run TACIT with three LLM backbones (DeepSeek-V4-Flash, Kimi-K2.6, GPT-5.6-sol) for cut contextualization and template generation, using five iterations of the framework per run. To match this budget, the LLM-only baseline is given five attempts per run, and its best formulation by training separation loss is kept. Additional implementation details are provided in Appendix C. TACIT substantially improves formulation repair across LLM backbones. Table 1 compares TACIT with LLM-only repair and AOP. TACIT improves every test metric across all backbones. AOP (Adapted Optimization Problem) never recovers a correct formulation: increasing its penalty weight c makes solutions significantly suboptimal before it makes them feasible (Table B.4 in the appendix). With DeepSeek-V4-Flash and Kimi-K2.6, TACIT nearly doubles the scenario recovery and recoverable rates compared to LLM-only: 19.5%→45.3%19.5\%→ 45.3\% and 31.6%→63.2%31.6\%→ 63.2\% respectively for DeepSeek-V4-Flash; 30%→55.3%30\%→ 55.3\% and 36.8%→71.1%36.8\%→ 71.1\%, for Kimi-K2.6. Importantly, TACIT remains beneficial even with the substantially stronger GPT-5.6-sol, where TACIT obtains additional 17.417.4 and 18.418.4 percentage points, respectively, and achieves a total 64.2%64.2\% recovery and 78.9%78.9\% recoverable rate of scenarios. Overall, TACIT improves performance across all reasoning models, with larger gains for weaker models, and is able to lift weaker models to approach the performance of much stronger models. Table 1 further shows that feasibility is recovered reliably across all backbones, suggesting that feasibility is not the primary bottleneck in formulation recovery; the harder challenge is recovering target-optimal behavior. Table 1: TACIT against LLM baselines under different LLM backbone models. Training Test Model ℒL ↓ sep. ↑ feas. ↑ opt. ↑ feas. ↑ opt. ↑ recovery ↑ recoverable ↑ AOP AOP linear (c=16c\!=\!\!16) 0.94 0.0% 0.57 0.07 0.57 0.04 0.0% 0.0% AOP tree (c=16c\!=\!\!16) 0.93 0.0% 0.58 0.10 0.57 0.07 0.0% 0.0% LLM-only DeepSeek-V4-F 0.64 18.9% 0.57 0.37 0.57 0.37 19.5% 31.6% Kimi-K2.6 0.56 29.5% 0.66 0.46 0.66 0.47 30.0% 36.8% GPT-5.6-sol 0.40 47.9% 0.74 0.59 0.75 0.59 46.8% 60.5% TACIT DeepSeek-V4-F 0.19 57.4% 0.79 0.64 0.78 0.61 45.3% 63.2% Kimi-K2.6 0.12 66.8% 0.87 0.77 0.85 0.73 55.3% 71.1% GPT-5.6-sol 0.12 66.3% 0.89 0.79 0.88 0.76 64.2% 78.9% TACIT provides the largest gains on structurally demanding misspecifications. Figure 2 breaks down test optimality by misspecification type, revealing a clear spectrum of difficulty. Some errors, such as variable-domain misspecifications, can be readily identified from the formulation context. In contrast, LLM-only baselines struggle when repair requires reconstructing structure absent from the initial formulation, such as missing variables or global constraints. TACIT substantially improves performance on these harder categories across backbones. For example, on missing variables, TACIT improves test optimality 0.30→0.440.30→ 0.44 with DeepSeek-V4-Flash and 0.46→0.740.46→ 0.74 with Kimi-K2.6; on global constraints, the improvements are 0.21→0.470.21→ 0.47 and 0.35→0.690.35→ 0.69. Similar gains arise for extra constraints. These results suggest that TACIT is most valuable when formulation repair goes beyond recognizing local errors and requires reconstructing missing model structure. Figure 2: Change in optimality rate induced by TACIT under different LLM backbone models. LLM reasoning and optimization play complementary roles. We ablate TACIT with DeepSeek-V4-Flash in Table 2. The top-down pathway is already strong, achieving recovery and recoverability of 41.1%41.1\% and 57.9%57.9\%, but incorporating the bottom-up pathway further improves them to 45.3%45.3\% and 63.2%63.2\%. The results also highlight the importance of combining LLM reasoning with optimization: the best pure approach, whether based only on optimization-driven cut generation or on LLM-only templates, achieves recovery and recoverability of 21.1%21.1\% and 31.6%31.6\%, less than half of the full system. Adding optimization-based calibration to the strongest pure approach, LLM-generated templates, raises recovery 21.1%→41.1%21.1\%→ 41.1\% and recoverability 31.6%→57.9%31.6\%→ 57.9\%. The breakdown in Table B.1 helps explain this complementarity: cut-based inference is particularly useful for local constraint errors, whereas templates are stronger when the repair requires new modeling structure, such as auxiliary variables. Together, these results show that TACIT benefits both from combining LLM reasoning with optimization and from combining top-down semantic reasoning with bottom-up evidence from observed decisions. Table 2: Ablation of TACIT components using DeepSeek-V4-Flash. All variants share preprocessing and objective calibration. Template only uses LLM-guessed constants. Training Test ℒL ↓ sep. ↑ feas. ↑ opt. ↑ feas. ↑ opt. ↑ recovery ↑ recoverable ↑ Obj. calibration only 0.76 5.8% 0.41 0.23 0.41 0.23 5.3% 5.3% Cuts 0.35 33.2% 0.57 0.33 0.54 0.27 14.7% 21.1% Cuts + contextualize 0.35 33.2% 0.59 0.35 0.57 0.30 17.9% 26.3% Template 0.60 22.6% 0.56 0.39 0.56 0.39 21.1% 31.6% Template + complete 0.31 47.9% 0.77 0.59 0.77 0.58 41.1% 57.9% TACIT 0.19 57.4% 0.79 0.64 0.78 0.61 45.3% 63.2% Performance under limited training data. Table B.2 shows that top-down inference is stable across training sizes, whereas bottom-up improves by 12.6 percentage points from 32 to 256 instances. TACIT combines both behaviors, maintaining strong performance across training sizes. Robustness to suboptimal feedback. We relax the assumption that observed target decisions are optimal, allowing up to 5%5\% suboptimality. Test feasibility remains unchanged (0.780.78 to 0.790.79), while test recovery decreases by 4.8 percentage points. This is a deliberately challenging setting: TACIT may never observe a target-optimal solution, yet is evaluated on whether it recovers target-optimal behavior. These results suggest that imperfect feedback still conveys useful structural information, allowing TACIT to remain robust even as exact preference recovery becomes harder; see Table B.3. The recovered transformations remain explicit and inspectable. Beyond predictive performance, TACIT returns modifications to the optimization formulation rather than an opaque correction of its outputs. Section B.2.3 illustrates this across three scenarios. In TP-Scenario2, it recovers the target exactly, adding xij≤24yijx_ij≤ 24y_ij for all i∈Ii∈ I, j∈Jj∈ J, and ∑i∈Iyij≤2 _i∈ Iy_ij≤ 2 for all j∈Jj∈ J. In the more challenging MCF-Scenario2, it fixes the objective function by introducing auxiliary variables and the cuts fij≤uijyijf_ij≤ u_ijy_ij for all i∈V,j∈Oii∈ V,j∈ O_i, plus the valid but redundant 0⋅yij≤fij0· y_ij≤ f_ij. Results are not always as clean. In GPU-Scenario4, the recovered objective −1.90∑i∈Isizi−0.10∑i∈Izi−2.42∑i∈I∑j∈Jixij-1.90 _i∈ Is_iz_i-0.10 _i∈ Iz_i-2.42 _i∈ I _j∈ J_ix_ij is equivalent under the problem constraints to a scaling of the target −∑i∈Isizi- _i∈ Is_iz_i with a small tie-breaking term −ϵ∑i∈Izi-ε _i∈ Iz_i. Table B.5 further shows how the cut-contextualization agent turns numerical cuts into interpretable constraints. Across inspected examples, TACIT recovers recognizable modeling constructs, such as linking constraints, combinatorial restrictions, auxiliary variables, and structured objective terms, rather than opaque instance-specific corrections. Even when non-canonical terms are present, the recovered formulations remain directly inspectable. 6 Conclusion Formulation repair is challenging: the source of misspecification is unknown, modeling logic may be absent from the initial formulation, and sparse feedback can be consistent with many possible repairs. We introduced TACIT, an end-to-end framework combining LLM-guided semantic reasoning with optimization-based search and validation to address this challenge. Across diverse formulation errors, it substantially improves recovery over the baselines, especially on structurally demanding misspecifications, while remaining effective with limited and imperfect feedback. Our results demonstrate that user corrections provide sufficient signal to systematically improve optimization models, a step toward models that learn from their mistakes. References Abdellaoui et al. (2026) A. Abdellaoui, A. Boufous, I. El Hallaoui, L. Benabbou, F. Aube, and M. Amazouz Learning implicit feasibility constraints for real-world routing and scheduling: application to log transportation. arXiv preprint arXiv:2606.05353. Cited by: §A.1, §2. AhmadiTeshnizi et al. (2024) A. AhmadiTeshnizi, W. Gao, H. Brunborg, S. Talaei, C. Lawless, and M. Udell OptiMUS-0.3: using large language models to model and solve optimization problems at scale. arXiv preprint arXiv:2407.19633. Cited by: §1, §2. Ao et al. (2026a) R. Ao, D. Simchi-Levi, and X. Wang Optirepair: closed-loop diagnosis and repair of supply chain optimization models with llm agents. arXiv preprint arXiv:2602.19439. Cited by: §2. Ao et al. (2026b) R. Ao, D. Simchi-Levi, and X. Wang Solver-in-the-loop: mdp-based benchmarks for self-correction and behavioral rationality in operations research. arXiv preprint arXiv:2601.21008. Cited by: §2. Astorga et al. (2024) N. Astorga, T. Liu, Y. Xiao, and M. van der Schaar Autoformulation of mathematical optimization models using llms. arXiv preprint arXiv:2411.01679. Cited by: §1, §2. Aswani et al. (2018) A. Aswani, Z. M. Shen, and A. Siddiq Inverse optimization with noisy data. Operations Research 66 (3), p. 870–892. External Links: Document Cited by: §2. Baxi et al. (2026) S. Baxi, K. Cummings, A. Jacquillat, S. Lo, R. McDonald, K. Mellou, I. Menache, and M. Molinaro Online rack placement in large-scale data centers: online sampling optimization and deployment. Operations Research. External Links: Document Cited by: §1. Bayani et al. (2024) M. Bayani, Y. Adulyasak, and L. Rousseau Learning and modeling implicit constraints in optimiza-tion models through decision trees. Les Cahiers du GERAD ISSN 711, p. 2440. Cited by: §A.1, §B.1, §2, §5.1. Besbes et al. (2025) O. Besbes, Y. Fonseca, and I. Lobel Contextual inverse optimization: offline and online learning. Operations Research 73 (1), p. 424–443. Cited by: §3. Bulut and Ralphs (2021) A. Bulut and T. K. Ralphs On the complexity of inverse mixed integer linear optimization. SIAM Journal on Optimization 31 (4), p. 3014–3043. External Links: Document Cited by: §2. Caro et al. (2026) F. Caro, J. Colliard, E. Katok, A. Ockenfels, N. Stier-Moses, C. Tucker, and D. J. Wu Introduction to the special issue on the human-algorithm connection. Management Science 72 (1), p. 1–13. External Links: Document Cited by: 3rd item. Chan et al. (2025) T. C. Chan, R. Mahmood, and I. Y. Zhu Inverse optimization: theory and applications. Operations Research 73 (2), p. 1046–1074. Cited by: §2, §3. Chen et al. (2024) H. Chen, G. E. Constante-Flores, and C. Li Diagnosing infeasible optimization problems using large language models. INFOR: Information Systems and Operational Research 62 (4), p. 573–587. Cited by: §2. Chen et al. (2026) H. Chen, G. E. Constante-Flores, K. S. I. Mantri, S. M. Kompalli, A. S. Ahluwalia, and C. Li OptiChat: bridging optimization models and practitioners with large language models. INFORMS Journal on Data Science 5 (3), p. 199–220. External Links: Document Cited by: 3rd item. Fajemisin et al. (2021) A. Fajemisin, D. Maragno, and D. den Hertog Optimization with constraint learning: a framework and survey. arXiv preprint arXiv:2110.02121. Cited by: §2. Hewitt and Frejinger (2020) M. Hewitt and E. Frejinger Data-driven optimization model customization. European Journal of Operational Research 287 (2), p. 438–451. Cited by: §A.1, §B.1, §2, §5.1. Jiang et al. (2025) C. Jiang, X. Shu, H. Qian, X. Lu, J. Zhou, A. Zhou, and Y. Yu LLMOPT: learning to define and solve general optimization problems from scratch. In The Thirteenth International Conference on Learning Representations, Cited by: §2. Kitaoka (2025) A. Kitaoka Inverse mixed-integer programming: learning constraints then objective functions. arXiv preprint arXiv:2510.04455. Cited by: §2. Kumar et al. (2021) M. Kumar, S. Kolb, L. De Raedt, and S. Teso Learning mixed-integer linear programs from contextual examples. arXiv preprint arXiv:2107.07136. Cited by: §2. Maragno et al. (2025) D. Maragno, H. Wiberg, D. Bertsimas, S. I. Birbil, D. den Hertog, and A. O. Fajemisin Mixed-integer optimization with constraint learning. Operations Research 73 (2), p. 1011–1028. External Links: Document Cited by: §2. Moghaddass and Terekhov (2021) M. Moghaddass and D. Terekhov Inverse integer optimization with multiple observations. Optimization Letters 15 (4), p. 1061–1079. External Links: Document Cited by: §2. Mohajerin Esfahani et al. (2018) P. Mohajerin Esfahani, S. Shafieezadeh-Abadeh, G. A. Hanasusanto, and D. Kuhn Data-driven inverse optimization with imperfect information. Mathematical Programming 167 (1), p. 191–234. External Links: Document Cited by: §2. Ren et al. (2025) K. Ren, P. Mohajerin Esfahani, and A. Georghiou Inverse optimization via learning feasible regions. In Proceedings of the 42nd International Conference on Machine Learning, Proceedings of Machine Learning Research, Vol. 267, p. 51471–51488. Cited by: §2. Tan et al. (2020) Y. Tan, D. Terekhov, and A. Delong Learning linear programs from optimal decisions. In Advances in Neural Information Processing Systems, Vol. 33. Cited by: §2. Thind et al. (2025) R. Thind, Y. Sun, L. Liang, and H. Yang Optimai: optimization from natural language using llm-powered ai agents. arXiv preprint arXiv:2504.16918. Cited by: §2. Xiao et al. (2025) Z. Xiao, J. Xie, L. Xu, S. Guan, J. Zhu, X. Han, X. Fu, W. Yu, H. Wu, W. Shi, Q. Kang, J. Duan, T. Zhong, M. Yuan, J. Zeng, Y. Wang, G. Chen, and D. Zhang A survey of optimization modeling meets LLMs: progress and future directions. arXiv preprint arXiv:2508.10047. Cited by: §2. Xiao et al. (2024) Z. Xiao, D. Zhang, Y. Wu, L. Xu, Y. Wang, X. Han, X. Fu, T. Zhong, J. Zeng, M. Song, and G. Chen Chain-of-experts: when LLMs meet complex operations research problems. In The Twelfth International Conference on Learning Representations, Cited by: §2. Zhang et al. (2024) J. Zhang, W. Wang, S. Guo, L. Wang, F. Lin, C. Yang, and W. Yin Solving general natural-language-description optimization problems with large language models. In Proceedings of the 2024 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies (Volume 6: Industry Track), p. 483–490. Cited by: §1, §2. Appendix A Proofs A.1 Limitation of embedded ML models for formulation correction As mentioned in Section 2, one approach for correcting formulations is by using an ML model to represent the user action of mapping from “incorrect” to “target” solution, and embedding this model within the optimization itself [Hewitt and Frejinger, 2020, Bayani et al., 2024, Abdellaoui et al., 2026]. That is, given an initial formulation ℳ0(d)=minc0(d)⊤x:x∈0(d),M_0(d)= \c_0(d) x:x _0(d) \, consider the modified problem ℳ0,f(d)=minc0(d)⊤x:x=f(x),x∈0(d),M_0,f(d)= \c_0(d) x:x=f(x),\ x _0(d) \, where f:ℝn→ℝnf:R^n ^n is a machine-learning model representing the user’s correction of a solution x into a solution f(x)f(x). The function f is learned so that, ideally, the optimal solutions of ℳ0,f(d)M_0,f(d) match the optimal solutions of the target formulation ℳ⋆(d)M (d) for every instance: argminℳ0,f(d)=(d,ℳ⋆)for all d. _0,f(d)=S(d;M ) all d. Some approaches relax the fixed-point equality x=f(x)x=f(x) through a Lagrangian penalty, i.e., the objective becomes c0(d)⊤x−λ‖x−f(x)‖∞c_0(d) x-λ\|x-f(x)\|_∞, but we stick to the original fixed-point equality to avoid the extra parameter λ. The following result shows that this approach cannot represent all formulation corrections. In particular, the limitation already arises when the initial formulation is missing a nonlinear term in the objective. Although such a term can be represented in a MILP using auxiliary variables and constraints, it cannot, in general, be recovered by restricting the feasible set of the original variables. In fact, the impossibility persists even if new constraints are added. We note that through the use of templates, our proposed system is able to handle such corrections. Theorem 1. There exist an initial formulation ℳ0M_0 and a target formulation ℳ⋆M such that no function f and no set K of additional constraints make the optimal solutions of ℳ0,f,K(d)≔minc0(d)⊤x:x=f(x),x∈0(d),x∈KM_0,f,K(d) \c_0(d) x:x=f(x),\ x _0(d),\ x∈ K \ equal to the optimal solutions of ℳ⋆(d)M (d) for every instance d. Proof. Consider the family of instances parametrized by the scalar d∈ℝd . The target formulation is ℳ⋆(d)=mindx+|x|:x∈−1,0,1,M (d)= \dx+|x|:x∈\-1,0,1\ \, whereas the initial formulation, which omits the nonlinear objective term, is ℳ0(d)=mindx:x∈−1,0,1.M_0(d)= \dx:x∈\-1,0,1\ \. The target formulation can equivalently be written as the MILP ℳ⋆(d):minx,y1,y2 (d): _x,y_1,y_2 dx+y1+y2 dx+y_1+y_2 s.t. .t. x=y1−y2, x=y_1-y_2, x∈−1,0,1, x∈\-1,0,1\, y1,y2∈0,1. y_1,y_2∈\0,1\. Thus, ℳ⋆M can be obtained from ℳ0M_0 by introducing auxiliary variables and constraints together with the missing objective term. For a function f:ℝ→ℝf:R and set K⊆ℝK , in this case we have ℳ0,f,K(d)=mindx:x=f(x),x∈−1,0,1,x∈K.M_0,f,K(d)= \dx:x=f(x),\ x∈\-1,0,1\,\ x∈ K \. We claim that for every f and K, there exists some d such that argminℳ0,f,K(d)≠Π0((d,ℳ⋆)). _0,f,K(d)≠ _0\! (S(d;M ) ). To see that, let S≔x:x=f(x),x∈−1,0,1,x∈KS \x:x=f(x),\ x∈\-1,0,1\,\ x∈ K \ be the feasible set of ℳ0,f,K(d)M_0,f,K(d). Importantly, S is independent of d, and hence ℳ0,f,K(d)=minx∈Sdx.M_0,f,K(d)= _x∈ Sdx. Consider d∈−2,0,2d∈\-2,0,2\. For these instances, the target optimal solutions are (−2,ℳ⋆)=1,(0,ℳ⋆)=0,(2,ℳ⋆)=−1.S(-2;M )=\1\, (0;M )=\0\, (2;M )=\-1\. Suppose by contradiction that the optimal-solution sets of ℳ0,f,K(d)M_0,f,K(d) and ℳ⋆(d)M (d) agree for all three values of d. Agreement at d=−2d=-2 requires 1 to be feasible for ℳ0,f,K(−2)M_0,f,K(-2), and therefore 1∈S1∈ S. Similarly, agreement at d=2d=2 requires −1∈S-1∈ S. When d=0d=0, however, the objective of ℳ0,f,K(0)M_0,f,K(0) is identically zero over S, so every feasible point is optimal: argminℳ0,f,K(0)=S. _0,f,K(0)=S. Since −1,1∈S-1,1∈ S, it follows that −1,1⊆argminℳ0,f,K(0).\-1,1\ _0,f,K(0). This contradicts (0,ℳ⋆)=0S(0;M )=\0\. Therefore no such f and K exist. ∎ Appendix B Extended Numerical Results B.1 Additional Results Table B.1: Test optimality rate per misspecification type, with DeepSeek-V4-Flash as LLM backbone. Objective Constraints Variables Constants Miscal. Missing Local Global Extra Missing Domain Missing All Instances 7 6 10 15 5 10 2 16 38 Initial model 0.24 0.22 0.20 0.11 0.17 0.18 0.01 0.13 0.17 Calib. only 0.49 0.26 0.20 0.11 0.28 0.21 0.01 0.13 0.23 Cuts 0.52 0.20 0.41 0.07 0.40 0.12 0.00 0.06 0.27 Cuts + contextualize 0.52 0.22 0.43 0.11 0.41 0.13 0.00 0.08 0.30 Template 0.59 0.37 0.29 0.24 0.50 0.31 1.00 0.17 0.39 Template + complete 0.60 0.46 0.55 0.49 0.77 0.43 1.00 0.51 0.58 All 0.61 0.43 0.72 0.47 0.68 0.44 1.00 0.51 0.61 Table B.2: Recovery rate of the final formulation against the number of training instances per scenario. Training instances 32 64 128 256 Calibration 4.7% 5.8% 5.3% 6.3% Cuts + contextualize 7.9% 13.7% 17.9% 20.5% Template + complete 36.8% 43.2% 41.1% 40.5% All 36.3% 45.8% 45.3% 43.2% Table B.3 compares our framework trained on optimal targets with training on targets that are up to 5% suboptimal. Let Z⋆(d)Z (d) be the optimal value of ℳ⋆(d)M (d) and, for a solution y, let Z(y,d)=c⋆(d)⊤yZ(y;d)=c (d) y. For each instance whose target differs from the initial solution, we draw x∼U(0,Δ)x U(0, ) with Δ=0.05 =0.05 and replace the target by a maximizer of Z(y,d)Z(y;d) over y∈⋆(d):Z(y,d)≤Z⋆(d)+x|Z⋆(d)|\y (d):Z(y;d)≤ Z (d)+x|Z (d)|\, i.e., the worst target-feasible solution within relative gap x. When x0x^0 admits a feasible lifting under ℳ⋆(d)M (d) with best objective Zinit(d)Z_init(d), we add Z(y,d)≤Zinit(d)−δ|Z⋆(d)|Z(y;d)≤ Z_init(d)-δ|Z (d)| with δ=0.005δ=0.005, so the new target still beats the initial solution by a relative margin of δ (instances where this set is empty are discarded). Table B.3: Performance of TACIT with DeepSeek-V4-Flash backbone on datasets with suboptimal target solutions. Training Test Dataset ℒL ↓ feas. ↑ opt. ↑ feas. ↑ opt. ↑ rec. % ↑ recoverable ↑ Optimal targets 0.19 0.79 0.64 0.78 0.61 45.3% 63.2% Suboptimal targets 0.19 0.81 0.58 0.79 0.53 40.5% 52.6% The Adapted Optimization Problem [Hewitt and Frejinger, 2020, Bayani et al., 2024] learns a mapping from the initial model’s optimum to the observed plan and penalizes deviations from that prediction, so it can only imitate the observed plans rather than recover the rule that produced them. In Table B.4, raising c makes its solutions satisfy the hidden constraint more often (feasibility from 0.51 to 0.62 and 0.52 to 0.64) but only by pulling them toward typical plans, so they stop being optimal (optimality from 0.13 to 0.01 and 0.15 to 0.04) and no run ever recovers the ground truth. Table B.4: AOP methods across different values of the penalty parameter c. Training Test Model ℒL ↓ sep. ↑ feas. ↑ opt. ↑ feas. ↑ opt. ↑ rec. % ↑ recoverable ↑ Initial 0.85 0.0% 0.46 0.17 0.46 0.17 - - AOP linear (c=1c=1) 0.90 0.0% 0.50 0.15 0.51 0.13 0.0% 0.0% AOP linear (c=16c=16) 0.94 0.0% 0.57 0.07 0.57 0.04 0.0% 0.0% AOP linear (c=256c=256) 0.98 0.0% 0.61 0.02 0.62 0.01 0.0% 0.0% AOP tree (c=1c=1) 0.91 0.0% 0.52 0.17 0.52 0.15 0.0% 0.0% AOP tree (c=16c=16) 0.93 0.0% 0.58 0.10 0.57 0.07 0.0% 0.0% AOP tree (c=256c=256) 0.95 0.0% 0.65 0.07 0.64 0.04 0.0% 0.0% B.2 Example Repaired Formulation B.2.1 Bottom-Up Table B.5 shows two cases where refining a cut recovers the missing constraint exactly. In GPU Scenario 3, the raw cut has near-degenerate coefficients. Because the variables ziz_i are binary, it still encodes the implication z0=1⇒zi=1z_0=1 z_i=1 for all i>0i>0. LLM rewrites it as the family in the more interpretable form z0≤ziz_0≤ z_i for all i>0i>0. In contrast, the template-based search never recovers a correct formulation on this scenario. In WA Scenario 3, the raw cut is already interpretable but applies to a single day and is not sufficient for out-of-sample test instances, so that raw cuts reach a test optimality of 00. The LLM refinement keeps employees 33 and 55 as fixed anchors, extends the cut over the day index d, and recovers the ground-truth constraint exactly. Table B.5: Example of cut processing on two scenarios. GPU Scenario 3: demand 0 can only be satisfied whenever all other demands are satisfied. Missing constraint: z0≤zi,∀i∈I,i>0z_0≤ z_i,\ ∀ i∈ I,\ i>0 Raw cut from ( P cut ): 0.9999z0−0.0001z1−0.0001z2−0.9996z3−0.0001z4≤00.9999\,z_0-0.0001\,z_1-0.0001\,z_2-0.9996\,z_3-0.0001\,z_4≤ 0 LLM refined cut: z0≤zi,∀i∈I,i>0z_0≤ z_i,\ ∀ i∈ I,\ i>0 WA Scenario 3: employees 3 and 5 can never work on the same day. Missing constraint: x3,d+x5,d≤1,∀d∈Dx_3,d+x_5,d≤ 1,\ ∀ d∈ D Raw cut from ( P cut ): 0.5x3,7+0.5x5,7−0.5≤00.5\,x_3,7+0.5\,x_5,7-0.5≤ 0 LLM refined cut: x3,d+x5,d≤1,∀d∈Dx_3,d+x_5,d≤ 1,\ ∀ d∈ D B.2.2 Top-Down Table B.6 shows three templates proposed by the LLM that recover the ground truth, and how the fitting step turns each into a concrete correction. In VRP Scenario 2, the template adds a variable z that bounds every route cost. It has no free constants so no fitting in necessary. In TP Scenario 3, the template adds both a new integer variable yi,jy_i,j and a new constant, the batch size L. The constraint calibration ( P constr ) recovers the true value L=2L=2. In CFL Scenario 7, the LLM proposes a general per-pair cap xi,j≤ui,jyix_i,j≤ u_i,j\,y_i without knowing which facility is restricted. Here, the constraint calibration ( P constr ) fit the constants ui,ju_i,j to capture the local rule: every cap is set to 11, which leaves the original constraint unchanged, except for facility 44, whose cap is set to 0.50.5. Table B.6: Example of template processing on three scenarios. Templates proposed by the LLM, before (raw) and after fitting the new constants with ( P constr ). Fitted values are shown in blue. Template (raw) Template (fitted) CVRP Scenario 2: the ground truth minimizes the longest route instead of the total distance. Variables: z∈ℝ≥0z _≥ 0 z∈ℝ≥0z _≥ 0 Constants: – – Constraints: ∑i∈N∑j∈Nj≠ici,jxi,j,k≤z,∀k∈K _i∈ N _ subarraycj∈ N\\ j≠ i subarrayc_i,j\,x_i,j,k≤ z,\ ∀ k∈ K ∑i∈N∑j∈Nj≠ici,jxi,j,k≤z,∀k∈K _i∈ N _ subarraycj∈ N\\ j≠ i subarrayc_i,j\,x_i,j,k≤ z,\ ∀ k∈ K TP Scenario 3: goods are shipped in batches of a fixed size. Variables: yi,j∈ℤ,∀i∈I,j∈Jy_i,j ,\ ∀ i∈ I,j∈ J yi,j∈ℤ,∀i∈I,j∈Jy_i,j ,\ ∀ i∈ I,j∈ J Constants: L L=2L= [rgb]0,0,12 Constraints: xi,j=Lyi,j,∀i∈I,j∈Jx_i,j=L\,y_i,j,\ ∀ i∈ I,j∈ J xi,j=2yi,j,∀i∈I,j∈Jx_i,j= [rgb]0,0,12\,y_i,j,\ ∀ i∈ I,j∈ J CFL Scenario 7: facility 4 can serve at most half of the demand of any customer. Variables: – – Constants: ui,j,∀i∈I,j∈Ju_i,j,\ ∀ i∈ I,j∈ J u4,j=0.5,ui,j=1(i≠4)u_4,j= [rgb]0,0,10.5,\ u_i,j= [rgb]0,0,11\ (i≠ 4) Constraints: xi,j≤ui,jyi,∀i∈I,j∈Jx_i,j≤ u_i,j\,y_i,\ ∀ i∈ I,j∈ J x4,j≤0.5y4,∀j∈Jx_4,j≤ [rgb]0,0,10.5\,y_4,\ ∀ j∈ J xi,j≤yi,∀i∈I∖4,j∈Jx_i,j≤ y_i,\ ∀ i∈ I \4\,j∈ J B.2.3 Final formulation samples In these examples, ℳ′M is the final formulation returned by TACIT. TP Scenario 2. At most K=2K=2 origins may ship to a given destination. Here TACIT recovers the target formulation exactly, up to the big-M constant (2424 instead of M=1000M=1000): ℳ⋆:minx,z : _x,z ∑i∈I∑j∈Jcijxij _i∈ I _j∈ Jc_ijx_ij s.t. .t. x∈TP, x _TP, xij≤Mzij, [rgb]0,0,1 x_ij≤ Mz_ij, ∀i∈I,j∈J, [rgb]0,0,1 ∀ i∈ I,\ j∈ J, ∑i∈Izij≤K, [rgb]0,0,1 _i∈ Iz_ij≤ K, ∀j∈J, [rgb]0,0,1 ∀ j∈ J, zij∈0,1, [rgb]0,0,1 z_ij∈\0,1\, ∀i∈I,j∈J. [rgb]0,0,1 ∀ i∈ I,\ j∈ J. ℳ′:minx,y : _x,y ∑i∈I∑j∈Jcijxij _i∈ I _j∈ Jc_ijx_ij s.t. .t. x∈TP, x _TP, xij≤24yij, [rgb]0,0.5898,0 x_ij≤ 24\,y_ij, ∀i∈I,j∈J, [rgb]0,0.5898,0 ∀ i∈ I,\ j∈ J, ∑i∈Iyij≤2, [rgb]0,0.5898,0 _i∈ Iy_ij≤ 2, ∀j∈J, [rgb]0,0.5898,0 ∀ j∈ J, yij∈0,1, [rgb]0,0.5898,0 y_ij∈\0,1\, ∀i∈I,j∈J. [rgb]0,0.5898,0 ∀ i∈ I,\ j∈ J. GPU Scenario 4. The target values the total demand fulfilled rather than the number of requests fulfilled. Since GPUX_GPU contains ∑j∈Jixij=sizi _j∈ J_ix_ij=s_iz_i, the incumbent objective is equivalent to −4.32∑i∈Isizi−0.10∑i∈Izi-4.32 _i∈ Is_iz_i-0.10 _i∈ Iz_i, i.e. the target objective scaled by 4.324.32 plus a small tie-breaker on the number of requests. ℳ⋆:minx,y,z : _x,y,z −∑i∈Isizi - _i∈ I [rgb]0,0,1s_i\,z_i s.t. .t. (x,y,z)∈GPU. (x,y,z) _GPU. ℳ′:minx,y,z : _x,y,z −1.90∑i∈Isizi−0.10∑i∈Izi−2.42∑i∈I∑j∈Jixij [rgb]0,0.5898,0 -1.90 _i∈ Is_iz_i-0.10 _i∈ Iz_i [rgb]0,0.5898,0-2.42 _i∈ I _j∈ J_ix_ij s.t. .t. (x,y,z)∈GPU. (x,y,z) _GPU. MCF Scenario 2. Minimize the number of used arcs. Here TACIT also recovers precisely an equivalent formulation (we note that f∈MCFf _MCF guarantees that f≥0f≥ 0, and so the last inequality in ℳ′M is valid, albeit redundant): ℳ⋆:minf,w : _f,w ∑i∈V∑j∈Oiwij [rgb]0,0,1 _i∈ V _j∈ O_iw_ij s.t. .t. f∈MCF, f _MCF, fij≤uijwij, [rgb]0,0,1 f_ij≤ u_ijw_ij, ∀i∈V,j∈Oi, [rgb]0,0,1 ∀ i∈ V,\ j∈ O_i, wij∈0,1, [rgb]0,0,1 w_ij∈\0,1\, ∀i∈V,j∈Oi. [rgb]0,0,1 ∀ i∈ V,\ j∈ O_i. ℳ′:minf,y : _f,y ∑i∈V∑j∈Oiyij [rgb]0,0.5898,0 _i∈ V _j∈ O_iy_ij s.t. .t. f∈MCF, f _MCF, fij≤uijyij, [rgb]0,0.5898,0 f_ij≤ u_ijy_ij, ∀i∈V,j∈Oi, [rgb]0,0.5898,0 ∀ i∈ V,\ j∈ O_i, 0⋅yij≤fij, [rgb]0,0.5898,0 0· y_ij≤ f_ij, ∀i∈V,j∈Oi, [rgb]0,0.5898,0 ∀ i∈ V,\ j∈ O_i, yij∈0,1, [rgb]0,0.5898,0 y_ij∈\0,1\, ∀i∈V,j∈Oi. [rgb]0,0.5898,0 ∀ i∈ V,\ j∈ O_i. Appendix C Implementation Details C.1 Routine and Subroutines Algorithms C.1 to C.4 summarize the framework of Section 4. We write ℳ⊕⋅M · for the formulation obtained by adding constraints, variables, or an instantiated template to ℳM, and C for the cuts accumulated across iterations. A single incumbent ℳ′M is maintained: every candidate formulation is scored by Evaluate, which compares it to the incumbent before and after objective calibration and keeps the best. Cuts are searched on ℳ′⊕M so that successive calls separate the solutions surviving the previous cuts, while templates are proposed from ℳ0M_0 to avoid compounding noise from previous modifications. Algorithm C.1 TACIT Framework 0: initial formulation ℳ0M_0, data D, iteration budget T 1: ℳ′←ℳ0M _0 with every constraint violated by some xi⋆x_i removed (preprocessing) 2: ℳ′←M ← Evaluate(ℳ′,ℳ′)(M ,M ) 3: ←∅C← 4: for t=1,…,Tt=1,…,T while ℒ(ℳ′,)>0L(M ;D)>0 do 5: ℳ′,←M ,C← SearchCuts(ℳ′,)(M ,C) (Sec. 4.1) 6: ℳ′←M ← SearchTemplates(ℳ′,ℳ0)(M ,M_0) (Sec. 4.2) 7: end for 8: return ℳ′M Algorithm C.2 Evaluate(ℳ′,ℳ)(M ,M): score a candidate ℳM and update the incumbent ℳ′M 1: if some xi⋆x_i has no lifting under ℳM then 2: return ℳ′M 3: end if 4: if ℒ(ℳ,)<ℒ(ℳ′,)L(M;D)<L(M ;D) then 5: ℳ′←ℳM 6: end if 7: θ←θ← solution of ( P obj ) on ℳM (Sec. 4.3) 8: ℳθ←(cθ,)M_θ←(c_θ,X) 9: if ℒ(ℳθ,)<ℒ(ℳ′,)L(M_θ;D)<L(M ;D) then 10: ℳ′←ℳθM _θ 11: end if 12: return ℳ′M Algorithm C.3 SearchCuts(ℳ′,)(M ,C): cut search and LLM refinement 1: ℳ←ℳ′⊕M 2: for ρ in 27,…,2−7\2^7,…,2^-7\ do 3: (a(0),b(0))←\(a^(0),b^(0))\← solution of the cut MIP on ℳM with penalty ρ (App. E.1) 4: (a(k),b(k))k≥1←\(a^(k),b^(k))\_k≥ 1← LLM-polished variants of (a(0),b(0))(a^(0),b^(0)) given ℳM 5: for k=0,1,…k=0,1,… do 6: ℳ′←M ← Evaluate(ℳ′,ℳ⊕a(k)⊤x≤b(k)) (M ,M \a^(k) x≤ b^(k)\ ) 7: ←∪a(k)⊤x≤b(k)C ∪\a^(k) x≤ b^(k)\ 8: end for 9: end for 10: ℳ′←M ← Evaluate(ℳ′,ℳ′⊕)(M ,M ) 11: for each constraint family G returned by the LLM as an extrapolation of C do 12: ℳ′←M ← Evaluate(ℳ′,ℳ′⊕)(M ,M ) 13: end for 14: return ℳ′M Algorithm C.4 SearchTemplates(ℳ′,ℳ)(M ,M): template generation and calibration 1: π←π← sample npairsn_pairs mismatched pairs (x^i,xi⋆)( x_i,x_i ) with x^i∈Π0((di,ℳ)) x_i∈ _0(S(d_i;M)), x^i≠xi⋆ x_i≠ x_i 2: τ1,…,τm←\ _1,…, _m\← templates returned by the LLM given ℳM and π 3: for j=1,…,mj=1,…,m do 4: if ( P constr ) is infeasible then 5: continue 6: end if 7: w←w← solution of ( P constr ) on ℳ⊕τjM _j 8: ℳ′←M ← Evaluate(ℳ′,ℳ⊕τj(w))(M ,M _j(w)) 9: end for 10: return ℳ′M C.2 Hyperparameters Each run uses N=128N=128 training instances unless stated otherwise and is evaluated on 256 test instances. We use rejection sampling to ensure that at least half of target solutions differ from the initial ones. The search runs for at most 5 iterations and stops early once the training loss is optimal. Cuts are generated by the hyperplane-separation MIP with an ℓ0 _0 penalty starting at 128 and halved until non-empty cuts are found. Template prompts show up to 16 model/target solution pairs, the constraints removed during preprocessing, and up to 5 templates that were returned by the LLM on previous iterations to avoid repetitions. All MIPs are solved with Gurobi on a single thread with a 30-second limit per instance. LLMs are queried with high reasoning effort and default temperature. C.3 Compute and runtime Runs are parallelized on an AMD EPYC 9734 processor, one run per core with Gurobi restricted to a single thread. LLMs are queried through hosted APIs with high reasoning effort. Each method is run 5 times per scenario, each run on a dataset generated with a different random seed, for at most 5 iterations and under a time budget of 6 hours per run. For datasets with N=128N=128 instances, the median runtime per run ranges from 2 min for calibration alone to 0.8 hours for template, 1.3 hour for cuts and refine, and 2.1 hours for the full framework. The runtime of the LLM-only baseline is 0.2 hour for the LLM-only baseline. We use two models in our framework: the large model, reported in the main text (DeepSeek-V4-Flash, Kimi-K2.6 or gpt-5.6-sol), generates templates and refine cuts, while the small model (always DeepSeek-V4-Flash) handles simpler tasks: split templates into variables, constants, and constraints, and translating natural-language modifications into optimization code. Averaged across the three large models, a run of our framework consumes 154k tokens from the large model and 346k tokens from the small model. The LLM-only baseline uses on average 210k tokens per run, all from the large model. Appendix D Benchmark Applications and Scenarios The benchmark consists of 38 scenarios built on nine base problems. Each scenario is a pair of formulations: the initial model used as the starting point, and the target model that generated the observed solutions. Table D.1 classifies what separates the two. Below, every problem is introduced with its notation, its base formulation and how instances are drawn, and its scenarios are then listed. Unless we say otherwise, the initial model is the base formulation and the target model is the base formulation with the stated change. Every model is written as a minimization, so maximization problems appear with a negated objective. Scenarios that single out specific indices (e.g. facility 4, or employees 3 and 5) are run on instances of fixed size so that these indices always exist. Numerical constants introduced by a target model (R, L, K, …) are hidden from the repair method, which only sees the initial model and the solutions. D.1 Capacitated facility location (CFL) Facilities are opened at a fixed cost and customers are assigned to open facilities, possibly splitting their demand. Let I be the facilities and J the customers. Customer j has demand djd_j, facility i has capacity CiC_i and opening cost fif_i, and serving the whole demand of j from i costs cijc_ij. Variable yi∈0,1y_i∈\0,1\ opens facility i and xij∈[0,1]x_ij∈[0,1] is the fraction of j’s demand served by i. min ∑i∈Ifiyi+∑i∈I∑j∈Jcijxij _i∈ If_iy_i+ _i∈ I _j∈ Jc_ijx_ij (4) s.t. ∑i∈Ixij≥1, _i∈ Ix_ij≥ 1, ∀j∈J, ∀ j∈ J, (5) ∑j∈Jdjxij≤Ciyi, _j∈ Jd_jx_ij≤ C_iy_i, ∀i∈I, ∀ i∈ I, (6) 0≤xij≤1,yi∈0,1, 0≤ x_ij≤ 1,\ y_i∈\0,1\, ∀i∈I,j∈J. ∀ i∈ I,\ j∈ J. (7) Instances have 6 to 8 facilities and 8 to 14 customers, djd_j uniform in [1,20][1,20], fif_i in [50,250][50,250] and cijc_ij in [1,100][1,100]. Capacities are Ci=⌈αid¯⌉C_i= _i d with d¯ d the total demand per facility and αi _i uniform in [1.5,2.5][1.5,2.5], so that roughly half of the facilities need to open. • S1: service radius. A facility can only serve customers within distance R=50R=50. The target adds zij∈0,1z_ij∈\0,1\ with xij≤zijx_ij≤ z_ij and cijzij≤Rc_ijz_ij≤ R for all i,ji,j. • S2: overestimated capacity. The target replaces (6) by the tighter ∑jdjxij≤0.8Ciyi _jd_jx_ij≤ 0.8\,C_iy_i. The initial model uses the full CiC_i. • S3: underestimated capacity. The target allows ∑jdjxij≤1.2Ciyi _jd_jx_ij≤ 1.2\,C_iy_i, so the capacity constraint of the initial model cuts off target solutions. • S4-S7: Will be released with the open-source version of the benchmark. D.2 Other problems The remaining 8 problems and their scenarios will be released with the open-source version of the benchmark. Table D.1: Taxonomy of scenario misspecifications over the 38 benchmark scenarios spanning 9 problems: CFL (capacitated facility location), GPU (GPU allocation), MIS (maximum independent set), MCF (minimum-cost flow), MPP (multi-period production planning), SC (set cover), TP (transportation), CVRP (capacitated vehicle routing), WA (workforce assignment). A constraint is local when the restriction it adds involves fixed indices (e.g. ∑j(x3,j+x5,j)≤1 _j (x_3,j+x_5,j )≤ 1) and global when it is stated over generic indices (e.g. ∑i,jxi,j≤1 _i,jx_i,j≤ 1). Extra marks a constraint of the initial model that cuts off target-feasible or target-optimal solutions. Constraints that only define an auxiliary variable are counted under missing variable rather than as a missing constraint, and big-M bounds are not counted as missing constants. Objective Constraints Variables Constants Scenario Miscalibrated Missing Local Global Extra Missing Domain Missing CFL S1 □ □ □ ■ □ ■ □ ■ S2 □ □ □ ■ □ □ □ ■ S3 □ □ □ ■ ■ □ □ ■ S4 ■ □ □ □ □ □ □ □ S5 ■ ■ □ □ □ ■ □ □ S6 □ □ □ □ □ □ ■ □ S7 □ □ ■ □ □ □ □ ■ GPU S1 □ ■ □ □ □ ■ □ □ S2 □ □ □ ■ □ □ □ □ S3 □ □ ■ □ □ □ □ □ S4 ■ □ □ □ □ □ □ □ S5 □ □ □ ■ □ □ □ ■ MIS S1 □ □ □ □ ■ □ □ □ S2 □ □ ■ □ □ □ □ □ S3 □ □ □ ■ □ ■ □ ■ MCF S1 □ □ □ ■ ■ □ □ □ S2 ■ ■ □ □ □ ■ □ □ MPP S1 ■ □ □ □ □ □ □ □ S2 □ □ □ ■ □ □ □ ■ SC S1 □ □ ■ □ □ □ □ ■ S2 □ □ □ □ ■ □ □ □ S3 □ □ ■ □ ■ □ □ □ S4 ■ □ □ □ □ □ □ □ S5 □ □ □ ■ □ □ □ ■ TP S1 □ □ □ ■ □ □ □ ■ S2 □ □ □ ■ □ ■ □ ■ S3 □ □ □ ■ □ ■ □ ■ S4 □ ■ □ □ □ ■ □ ■ S5 □ □ □ □ □ □ ■ □ S6 □ □ ■ □ □ □ □ □ CVRP S1 □ □ □ ■ □ □ □ ■ S2 ■ ■ □ □ □ ■ □ □ S3 □ □ ■ □ □ □ □ □ S4 □ □ ■ □ □ □ □ □ WA S1 □ □ □ ■ □ □ □ ■ S2 □ ■ □ ■ □ ■ □ ■ S3 □ □ ■ □ □ □ □ □ S4 □ □ ■ □ □ □ □ □ Appendix E Additional Details E.1 Cut Search Definition 1 (Variable family). Let i(ℳ)K_i(M) be the set of indices of the decision variables of ℳ(di)M(d_i), whose size may vary across instances. Each variable is identified by a symbol and a tuple of indices ranging over sets that are either shared by all instances or instance-dependent. The family t(k)t(k) of variable k is obtained by dropping its indices with instance-dependent sets. We denote by (ℳ)T(M) the set of families. In particular, when every instance shares the same index sets, each variable forms its own family. The intuition behind families is that weights learned from data must be defined at the family level: a weight attached to a family applies to every instance, whereas a weight attached to an individual variable is meaningless on instances where that variable does not exist. For instance, consider the VRP example (Example 1) where there is a fixed fleet of 5 vehicles ℒL for all instances, but the customer set C varies across instances. The routing variable xijℓx_ij indicates vehicle ℓ travels from customer i to j. A variable index is a tuple k=(i,j,l)∈N×N×1,…,5k=(i,j,l)∈ N× N×\1,…,5\, whose customer components i,ji,j are instance-dependent and whose vehicle component ℓ is shared. In this case, there is one family per vehicle, xijl:(i,j)∈N×N\x_ijl:(i,j)∈ N× N\ for l∈1,…,5l∈\1,…,5\. In particular, it is not possible to learn customer-dependent weights that apply to all instances. Let φk(d) _k(d) be the elements of d whose instance-dependent indices all appear among the indices of variable k. Elements indexed only by index sets identical across instances belong to every φk(d) _k(d), and we denote this common part by φ0(d) _0(d). Define ϕk(d)=(1,φk(d)) _k(d)= (1, _k(d) ). A cut then reads a(d)⊤x≤b(d)a(d) x≤ b(d) with a(d)k=αt(k)⊤ϕk(d)a(d)_k= _t(k) _k(d) and b(d)=β⊤ϕ0(d)b(d)=β _0(d), where αt(k) _t(k) and β are weights to be inferred. We solve the following MILP to perform this inference and find cuts with sparsity controlled by a parameter ρ: maxα,β,z,η _α,β,z,η 1|ℐ|∑i∈ℐzi−ρ(‖α‖0+‖β‖0)+ϵη 1|I| _i z_i-ρ (\|α\|_0+\|β\|_0 )+εη (cutP_cut) s.t. ai⊤xi⋆−bi≤0, a_i x_i -b_i≤ 0, ∀i∈ℐ, ∀ i , ai⊤x^i−bi≥η−M(1−zi), a_i x_i-b_i≥η-M(1-z_i), ∀i∈ℐ, ∀ i , ai,k=αt(k)⊤ϕk(di), a_i,k= _t(k) _k(d_i), ∀i∈ℐ,∀k∈(di), ∀ i ,\;∀ k (d_i), bi=β⊤ϕ0(di), b_i=β _0(d_i), ∀i∈ℐ, ∀ i , z∈0,1|ℐ|,η≥η¯,‖α‖∞≤1,‖β‖∞≤1. z∈\0,1\^|I|, η≥ η, \|α\|_∞≤ 1, \|β\|_∞≤ 1. The first constraint makes the cut valid for every target, and the binary ziz_i certifies that x^i x_i violates it by at least the margin η≥η¯>0η≥ η>0. The objective maximizes the share of solutions of ℳM that are cut off, penalizes the number of nonzero weights ‖α‖0+‖β‖0\|α\|_0+\|β\|_0 (linearized with binaries ui,k≥|αi,k|u_i,k≥| _i,k| and vi≥|βi|v_i≥| _i|, which also yield the bound ‖α‖∞≤1\|α\|_∞≤ 1 and ‖β‖∞≤1\|β\|_∞≤ 1) and breaks ties with a small reward on the margin with 0<ϵ≪10<ε 1. The penalty ρ trades separation for sparsity: a ρ close to 0 yields the densest and most separating cut, whereas a large ρ yields cuts with few terms, which are more interpretable and less prone to overfitting. The cut search sweeps ρ downward to collect cuts of increasing density, from the sparsest nonempty one to the unregularized one, and evaluates each by the separation loss. E.2 Template completion We calibrate the template weights w to preserve all observed targets while maximally separating the optimal solutions of the current formulation ℳM. Preservation requires each xi⋆x_i to admit a lifting yi⋆y_i into the non-primary variables of ℳM and an assignment of the new variables zi⋆z_i such that (yi⋆,zi⋆)(y_i ,z_i ) belongs to the new feasible set τ(di,w)X_τ(d_i;w). For the second goal, define Vτ(y,z,w,d)≜∑j∈Jτ(d)[gj(y,z,w,d)]+,V_τ(y,z,w;d) _j∈ J_τ(d)[g_j(y,z,w;d)]^+, which measures the total violation of the template constraints by a solution (y,z)(y,z). Since an optimal solution y^i y_i of ℳM does not specify the new variables z, it is excluded by the template only if every completion z^i z_i violates its constraints. Thus, for a given w, its violation is measured by minz^i∈Zτ(di)Vτ(y^i,z^i,w,di), _ z_i∈ Z_τ(d_i)V_τ( y_i, z_i,w;d_i), i.e., the violation under the completion of the new variables that best satisfies the template. Combining these two requirements, we determine the template weights w by maxw∈,(yi⋆,zi⋆)i∈ℐ _w ,\,(y_i ,z_i )_i ∑i∈ℐminz^i∈Zτ(di)Vτ(y^i,z^i,w,di) _i _ z_i∈ Z_τ(d_i)V_τ( y_i, z_i,w;d_i) (constrP_constr) s.t. (yi⋆,zi⋆)∈τ(di,w), (y_i ,z_i ) _τ(d_i;w), ∀i∈ℐ, ∀ i , (8) Π0(yi⋆)=xi⋆, _0(y_i )=x_i , ∀i∈ℐ. ∀ i . (9) For scale-invariant templates, we normalize the corresponding components of w. Problem ( P constr ) has a max-min structure, jointly calibrating the template parameters w against the best completions z^i z_i of the new variables. We solve this problem via constraint generation and discard any template where no weights allow every target to be feasibly lifted. E.3 Objective Calibration As with cuts, we parameterize objective coefficients as affine functions of instance data, with one weight vector per variable family. The objective coefficient of variable k is cθ(di)k=θt(k)⊤ϕk(di)c_θ(d_i)_k= _t(k) _k(d_i), where ϕk(di) _k(d_i) denotes data associated with variable k and θt(k) _t(k) is the vector to be learned for family t(k)t(k). We seek weights θ that balance two goals. First, each target solution xi⋆x_i should admit a feasible lifting yi⋆y_i that is nearly optimal under the calibrated objective. We allow some suboptimality to accommodate potentially suboptimal target solutions in practice. Second, the lifted target yi⋆y_i should outperform the current model solution y^i y_i by as large a margin as possible; equivalently, we seek an objective vector cθ(di)c_θ(d_i) for which cθ(di)⊤(y^i−yi⋆)c_θ(d_i) ( y_i-y_i ) is large. We therefore calibrate θ by solving minθ∈Θ,(yi⋆,εi)i∈ℐ _θ∈ ,\,(y_i , _i)_i ∑i∈ℐεi−λ∑i∈ℐcθ(di)⊤(y^i−yi⋆) _i _i-λ _i c_θ(d_i) ( y_i-y_i ) (objP_obj) s.t. cθ(di)⊤(yi⋆−y)≤εi c_θ(d_i) (y_i -y)≤ _i ∀i∈ℐ,∀y∈(di), ∀ i ,\ ∀ y (d_i), (10) yi⋆∈(di),Π0(yi⋆)=xi⋆ y_i (d_i), _0(y_i )=x_i ∀i∈ℐ, ∀ i , (11) εi≥0 _i≥ 0 ∀i∈ℐ. ∀ i . (12) At an optimum, εi=cθ(di)⊤yi⋆−miny∈(di)cθ(di)⊤y≥0, _i=c_θ(d_i) y_i - _y (d_i)c_θ(d_i) y≥ 0, so ϵi _i precisely captures the suboptimality of the lifted target solution under the calibrated objective. The parameter λ>0λ>0 controls the tradeoff between target suboptimality and separation from the current model solutions. As with template calibration, we solve Problem ( P obj ) via constraint generation.