Do LLMs Know When Their Simplifications Break?

Engineers rarely optimize the real system. They optimize a simplified stand-in. A battery becomes a tank with constant efficiency. A degradation curve becomes a straight line around the current operating point. A network of coupled warehouses becomes independent warehouses. These simplifications are fine inside some range of conditions and quietly wrong outside it. Large language models (LLMs) are now being asked to write these stand-in models from plain-language descriptions and hand them to numerical solvers. Existing tests check whether the model's formulation solves and satisfies its own constraints. They do not check whether it is physically faithful to the system it claims to represent. A model can produce a correct, optimal answer to the wrong problem, and nothing in today's pipelines will notice.

This note proposes to measure and reduce that failure. We build matched pairs of scenarios that are identical except for one parameter that pushes a standard simplification past its validity limit. One example is fast charging at 25°C versus −10°C, where lithium plating makes linear aging models fail. We then ask whether an LLM changes its formulation when, and only when, it should. Every plan is scored in a higher-fidelity simulator, not in the LLM's own model. We also test one intervention. The LLM must write down each assumption together with a numeric validity range. Those ranges are checked mechanically against the scenario and a few cheap simulator probes, and a violation triggers a richer formulation. The claim is that "fidelity errors" (formulations that are feasible but physically wrong) are a distinct and largely unmeasured LLM reasoning failure. The claim is also that making assumptions explicit and checkable fixes much of it more cheaply than always using the expensive model.

Core Claim

Two points support the claim, and one result constrains it.

The first point is that current LLM-plus-solver systems treat the problem specification as given. Agentic Numeric Optimization for Nutrition Planning has the LLM bound the search space and then calls a mixed-integer linear program (an optimizer over linear objectives with some integer variables). It lifts calorie adherence from 9.0% to 79.5%, but its linear nutrient-summation model is never questioned. ASTRA lets the LLM tune scalar weights of a fixed linear program. The LLM-assisted EV charging planner has the LLM write a formulation that omits battery aging, temperature, and transformer limits altogether. In all three, the LLM's modeling judgment is never scored against the physical system.

The second point is that the closest benchmark measures something different. FrontierOR scores LLM-written algorithms on 180 large optimization problems by quality and runtime against Gurobi, and finds that weaker models fail at constraint formulation. The ground-truth problem in FrontierOR is fixed. Ours is not: we ask whether the LLM picks a simplification whose error is acceptable for the scenario at hand.

We expect fidelity errors to show the pattern described in Can Large Language Models Always Solve Easy Problems if They Can Solve Harder Ones?, which found that models solving hard instances fail on easier variants with superficial changes. Our prediction is the mirror image. Models will write fluent, sophisticated convex formulations, yet fail to notice that a single changed number (ambient temperature, a cost-curvature ratio) invalidates them. This is the kind of surface-level reasoning that Evaluating Intermediate Reasoning of Code-Assisted LLMs for Mathematics found hidden behind executable code.

The constraining result comes from Aging-aware battery control via convex optimization. It shows that a fixed first-order Taylor convexification predicts battery lifetime at 5.70 versus 5.60 years for the nonlinear model, within 2%. Simplification is often fine. The research question is therefore narrow: can the system tell the 2% cases from the cases where it is not fine?

Research Program

The first component is a regime-pair benchmark in three domains, each with an evaluator stronger than the simplification under test.

The first domain is battery energy arbitrage on ERCOT North Hub hourly prices. The simplified model is the convexified aging model of Nnorom et al. The evaluator is a reduced-order degradation model with coupled solid-electrolyte-interphase growth, active-material loss, and lithium plating, following Dual Closed-Loops Capacity Evolution Prediction. It is calibrated on cycle data from BatteryML, using chemistry-matched LFP subsets. Regime breaks come from low-temperature fast charging, motivated by The Dilemma of C-Rate and Cycle Life. Calibration quality is itself a risk, and we will report evaluator error on held-out cells before using it as ground truth.

The second domain is EV charging in Chargax. We extend the simulator with the effects its authors explicitly leave out: a shared transformer limit and temperature-dependent degradation. The regime break is aggregate load crossing transformer capacity.

The third domain is multi-location inventory. Here The Price of Simplicity gives an analytical worst-case ratio of $h/l$, which characterizes how nonlinear the ordering cost is. It also reports empirical decoupled-policy cost ratios of 1.13–1.18. This domain gives us ground truth that does not depend on our own simulator.

Each benchmark item is a plain-language task description plus scenario data. Its pair partner differs in one parameter that crosses a validity boundary. Boundaries are set by sweeping the parameter and finding where the simplified model's regret in the evaluator exceeds a tolerance. We will use 5% and also report other levels.

The second component is the intervention, an assumption ledger. Alongside its formulation, the LLM must emit each simplifying assumption, the physical quantity it depends on, and a numeric validity range. An example entry: "linear aging valid for cell temperature above 10°C and C-rate below 1C."

A non-LLM checker does two things. It compares the ranges against scenario parameters. It also runs a small number of cheap probes of the evaluator at the planned operating points; the probe budget is fixed and reported. If either check flags a violation, the LLM is asked to revise only the flagged component. The revision might mean re-linearizing at a new point, adding a plating penalty, or coupling the decoupled sites.

The design follows the lesson of Divide-and-Conquer Prompting, which shows that isolating subtasks keeps errors from contaminating the rest of the context. Each assumption is checked separately and numerically rather than judged inside one long chain of reasoning.

The third component is cost accounting. The Economical Prompting Index penalizes tokens only. C3PO bounds API dollars only. We report total cost as token cost, plus solver and probe compute, plus physical regret in the evaluator (lost revenue and degradation priced at replacement cost). This total is what decides whether escalating to a richer model was worth it.

Baselines

The naive reference is a one-shot LLM formulation, in the style of the EV planning system and the ANO pipeline. The LLM writes the model, the solver solves it, and nothing checks fidelity. It shows how often fidelity errors occur by default. We run it with the same LLMs, prompts that include the full task description, and the same solver.

The strongest domain baseline is the fixed expert simplification: the Taylor-convexified aging model of Nnorom et al., the decoupled base-stock policy of John et al., and Chargax's default model. On its home turf this baseline is very good. Nnorom et al. report lifetime prediction within 2% (5.70 versus 5.60 years), and John et al. report decoupled cost ratios of 1.13–1.18. Our method must match it on the benign half of each pair and beat it on the broken half. If it does not, the LLM adds nothing.

The upper reference is to always use the high-fidelity model, or the centralized formulation in the inventory and EV cases. It bounds achievable regret. It also shows the compute price that motivates simplification in the first place: the EV planning paper reports 50 minutes and 76.31 GB for a centralized solve, against about 30 seconds for the decomposed one.

The strongest existing agentic method is solver-feedback self-refinement in the style of CORAL, as evaluated in FrontierOR, where it raised Quality-Time Efficiency to 0.50 on selected hard tasks. We give it the same number of LLM calls and the same evaluator-probe budget as our method. The difference is that its feedback is unstructured: solver status and objective values, rather than per-assumption range checks. There is no reported result on Lacuna for any method on regime-pair fidelity tasks, so all numbers on our benchmark will be new.

Two ablations isolate the key ingredient. The first is a ledger without checking: the LLM states assumptions and ranges but nothing verifies them. This tests whether writing assumptions down helps on its own. The second is checking without the LLM: an expert-written list of assumption ranges for each domain, applied mechanically. This is the rule-based competitor.

Beating the field means the following. On broken pairs, our method must have lower total cost than the fixed expert simplification and the CORAL-style loop. On benign pairs, its regret must stay within the tolerance of the expert simplification. And its compute must be well below always-high-fidelity.

Why not just…?

Why not just run successive convex approximation automatically, with no LLM? Re-linearizing a known nonlinear model at each new operating point is mechanical, and if the nonlinear model is available it will beat any LLM at that step. We grant this, and our system uses mechanical re-linearization wherever the right model is already specified. The failure we target is upstream of that step: the formulation omits the mechanism entirely, as the EV planner omits transformer limits and aging. Re-linearizing a model that has no plating term never produces one. The broken pairs in the Chargax and low-temperature battery domains are built so that the missing term is structural, and an automatic re-linearization baseline on the naive formulation will show directly whether this objection holds.

Why not just use expert rules for when each simplification is valid? This is the real threat. In domains where experts have already listed validity ranges, the checking-without-LLM ablation may match our method, and we will report that honestly. The LLM can only add value where no such list exists. To test this, we write the rule list for battery arbitrage and then evaluate both systems on regime breaks the list did not anticipate, such as transformer coupling in Chargax and cost curvature in inventory. If expert rules transfer as well as LLM-written ledgers, the contribution narrows to a benchmark finding about fidelity errors, and we will frame it that way.

Why not just always use the high-fidelity model? In the inventory and EV settings, the high-fidelity version is a centralized or nonlinear integer problem. That is exactly where FrontierOR reports Gurobi failing on 46% of large instances within an hour, and where the centralized EV solve took 50 minutes. The always-high-fidelity baseline is in the comparison precisely so that the total-cost metric decides whether selective escalation pays off.

Why not just train a reinforcement learning controller in a fast simulator? A controller trained in Chargax inherits Chargax's simplifications, so it is blind to the same regime breaks unless the simulator is fixed first. Fixing the simulator is the high-fidelity baseline in another form. We include a trained controller on the extended simulator as a secondary reference, but it does not answer the question of LLM modeling judgment.

Decisive Checks

The first check is pair sensitivity. For each model, we measure the fraction of regime pairs where the formulation changes on the broken side and stays the same on the benign side. If one-shot formulations score near chance, fidelity errors are real and unmeasured. If even naive LLMs adapt reliably, the motivating claim is wrong and we stop.

The second check is the ledger against the CORAL-style refinement loop at matched call and probe budgets. If the gain comes only from extra simulator probes, structured per-assumption checking adds nothing over generic feedback.

The third check is the transfer test between LLM-written ledgers and expert rules on unanticipated breaks, described above.

Finally, we report total cost (tokens, compute, and physical regret) against compute for every method. The result should show whether a cascade that prices physical regret, which neither EPI nor C3PO models, changes which strategy is economical.