OptiAgent: End-to-End Optimization Modeling via Multi-Agent Iterative Refinement

Adriana Laurindo Monteiro; Gabriel Mattos Langeloh; Gustavo de Oliveira Kanno; Nayse Fagundes; Priscila Louise Aguirre; Thiago Costa Rizuti da Rocha; Victor Leme Beltran

REVIEW 3 major objections 10 minor 14 references

Multi-agent feedback loops hit 100% accuracy on optimization modeling

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · glm-5.2

2026-07-07 15:53 UTC pith:XBQPLECC

load-bearing objection Multi-agent OR modeling with targeted feedback loops; strong empirical gains but missing ablation to attribute improvement to architecture rather than raw compute. the 3 major comments →

arxiv 2607.05346 v1 pith:XBQPLECC submitted 2026-07-06 cs.AI cs.MA

OptiAgent: End-to-End Optimization Modeling via Multi-Agent Iterative Refinement

Adriana Laurindo Monteiro , Nayse Fagundes , Gabriel Mattos Langeloh , Gustavo de Oliveira Kanno , Priscila Louise Aguirre , Thiago Costa Rizuti da Rocha , Victor Leme Beltran This is my paper

classification cs.AI cs.MA

keywords multi-agent systemsoperations researchoptimization modelinglarge language modelsfeedback loopsnatural language to codeautomated formulation

verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper introduces OptiAgent, a multi-agent system that converts natural-language descriptions of operations research problems into solver-ready mathematical formulations and executable code. The architecture decomposes the modeling pipeline into six specialized agents—interpretation, formulation, analysis, validation, code generation, and solving—connected by four targeted feedback loops that automatically detect and route errors back to the responsible agent for correction, without human intervention. The central claim is that this decomposition plus iterative self-correction produces more accurate optimization models than single-pass LLM generation, while making every step of the modeling process auditable. The system achieves best-known results on 3 of 4 benchmarks spanning linear, mixed-integer, and nonlinear programming, with particularly large gains on the most complex and least-memorizable dataset.

Core claim

The paper demonstrates that breaking the natural-language-to-optimization-model pipeline into specialized agents with targeted feedback loops—each loop addressing a distinct failure mode such as misinterpretation, structural defects, mathematical inconsistencies, or code errors—yields substantially higher solving accuracy than single-pass generation, especially on complex, out-of-distribution problems. The feedback loops fire on 28-61% of problems depending on dataset complexity, and the system achieves perfect accuracy on the simplest benchmark while showing its largest relative gains on the hardest. The authors argue that architectural decomposition, not prompt engineering, drives theImpro

What carries the argument

Six sequential agents (Interpretation, Formulation, Analysis, Validation, Code Generation, Solver) sharing a common state, connected by four feedback loops: Loop 1 routes validation failures back to formulation, Loop 2 routes fundamental misinterpretation back to interpretation, Loop 3 routes structural issues back to formulation, and Loop 4 routes code execution errors back to code generation. Each loop is capped at three iterations. The five-element formulation (Sets, Parameters, Variables, Objective, Constraints) serves as the shared intermediate representation between agents.

Load-bearing premise

The paper attributes its performance gains to the multi-agent feedback architecture, but does not run ablation studies isolating the feedback loops from the task decomposition, and evaluates each configuration only once without error bars, making it impossible to confirm that the architecture itself—rather than the choice of LLM backbone or a lucky single run—is responsible for the improvement.

What would settle it

If an ablation removing all four feedback loops (keeping only the six-agent sequential pipeline) produced accuracy within a few percentage points of the full system, the central claim that iterative self-correction is a key driver of improvement would be undermined.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

If the feedback-loop architecture is the true driver of improvement, then any LLM-based pipeline for structured reasoning tasks—not just optimization—could benefit from decomposing into specialized validators with targeted error-routing.
The transparency property means that expert users can debug generated models at the formulation level before any code runs, potentially reducing the cost of operations research expertise in industrial settings.
The finding that gains are largest on the most complex, least-memorizable dataset suggests the architecture helps with genuine reasoning rather than pattern recall, which would matter for any domain where pretraining data is scarce.
The loop-rate analysis (28-61% of problems trigger feedback) provides a quantitative signal for where LLM reasoning fails most often in optimization modeling, which could guide future prompt or agent design.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

The absence of ablation studies means the paper cannot distinguish whether the gains come from the feedback loops, the task decomposition, or simply from using a stronger LLM backbone than baselines. If the decomposition alone (without feedback) captures most of the benefit, the feedback loops may add complexity without proportional value.
The single-run, temperature-0 evaluation protocol leaves open whether the architecture's gains are stable or partly artifacts of a favorable draw. Repeated trials could reveal whether the feedback loops reduce variance or merely shift the mean.
The system's perfect score on ComplexOR and weaker relative performance on NLP4LP (the largest dataset) raises the question of whether the architecture scales to harder problems or whether the feedback loops converge on locally correct but globally suboptimal formulations.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Desk Editor's Note

Multi-agent OR modeling with targeted feedback loops; strong empirical gains but missing ablation to attribute improvement to architecture rather than raw compute.

read the letter

The paper you should know about is OptiAgent, a six-agent pipeline for converting natural-language OR problem descriptions into solver-ready formulations and code. The headline result is state-of-the-art on 3 of 4 benchmarks (LP, MILP, NLP), with the largest gains on the hardest, most recent dataset (LogiOR: 70.65% vs. 60.87% for the best single-pass baseline). The architecture is clean: interpretation → formulation → analysis → validation → code generation → solver, with four targeted feedback loops that route errors back to specific upstream agents. The validation agent catching a missing index definition before code is generated (Figure 2) is a concrete, well-chosen example of what the feedback loops buy you. The transparency argument — each agent exposes reasoning, making the pipeline auditable — is the paper's most distinctive contribution and is genuinely useful for practitioners. The internal baselines using the same LLM backbone and five-element formulation are a real attempt at fair comparison, and the prompt templates in the appendix are concrete enough to reproduce. Credit where it's earned: the system design is well-motivated, the datasets are standard, and the results are reported honestly (including the one dataset where OptiAgent underperforms). Now the soft spots. The reader and stress-test both flag the same issue, and they're right: the paper attributes improvement to architectural decomposition and feedback loops, but there's no ablation. OptiAgent invokes the LLM substantially more times per problem than the baseline (feedback loops trigger on 33–61% of problems, each adding multiple calls). A compute-matched single-agent baseline — same backbone, similar total LLM invocations, no decomposition — would settle whether the gains come from architecture or from spending more compute. The paper acknowledges this gap explicitly in Future Work, which is honest, but it's still the load-bearing gap. The single-run evaluation (temperature 0, no error bars) is a lesser concern; the margins on LogiOR and IndustryOR are large enough that variance is unlikely to erase them, but it should be addressed. The backbone confound with external baselines (ORThought, CoE, etc. use different models) is real but partially mitigated by the internal baselines. The reader rated soundness at 4.0; I'd push that to 4.5 — the methodological gaps are acknowledged and the internal comparisons are more controlled than the reader suggests. The novelty rating of 5.0 is about right: the multi-agent pattern is not new, but the four targeted feedback loops applied to OR modeling with specific failure-mode routing is a legitimate system contribution. This paper is for researchers and practitioners working on LLM-based optimization modeling. It deserves a serious referee. The key revision is straightforward: run the ablation (remove feedback loops, remove individual agents, add a compute-matched single-agent control) and report multi-run variance. If the gains survive that, the contribution is solid.

Referee Report

3 major / 10 minor

Summary. The paper proposes OptiAgent, a multi-agent framework for translating natural-language Operations Research problem descriptions into solver-ready mathematical formulations and executable code. The architecture comprises six specialized agents (Interpretation, Formulation, Analysis, Validation, Code Generation, Solver) connected in a sequential pipeline with four targeted feedback loops for iterative self-correction. The framework adopts the five-element optimization formulation (Sets, Parameters, Variables, Objective, Constraints) from prior work. Experiments are conducted on four standard benchmarks (ComplexOR, IndustryOR, LogiOR, NLP4LP) using Claude Sonnet 4.5 and GPT-5.4 as backbones, with temperature set to 0. The authors report state-of-the-art solving accuracy on 3 of 4 datasets and highlight the transparency benefits of the modular design.

Significance. The paper addresses a practically important problem in the LLM-for-OR pipeline: making the modeling process transparent and self-correcting rather than a single-pass black box. The multi-loop validation architecture with specialized feedback mechanisms is a reasonable engineering contribution, and the qualitative example in Figure 2 concretely illustrates how the feedback loops catch formulation errors (e.g., undefined variables) before code generation. The framework is model-agnostic in principle, tested on two LLM families. However, the central attribution claim—that architectural decomposition and feedback loops are the key drivers of improvement—lacks the ablation evidence needed to distinguish architectural design from increased compute budget. The absence of variability measures and a compute-matched control limits the strength of the empirical claims.

major comments (3)

§4, final paragraph and §5, Future Work: The paper asserts that 'architectural decomposition, not prompt engineering, is the key driver of improvements' (§4), but this claim is not supported by the reported experiments. Table 3 shows that feedback loops trigger on 33–61% of problems, each adding multiple LLM calls beyond the single-pass baseline. Without a compute-matched control (e.g., a single-agent system allowed the same number of LLM invocations or retry attempts per problem), the observed gains could be attributable to increased total compute rather than to the multi-agent decomposition or targeted feedback mechanisms. The authors acknowledge this gap in §5 ('We plan to remove or modify individual agents... [and] ablate the feedback loop mechanism'), but the attribution claim in §4 is presented as established rather than as a hypothesis. This is load-bearing for the paper's central
Table 2, NLP4LP column: OptiAgent (GPT 5.4) achieves 87.12% SA, but the baseline GPT 5.4 with system prompt already achieves 81.61%, and LLMOPT reports 83.8%. The improvement margin over the strongest baseline is approximately 3.3–5.5 percentage points. Given that all experiments use temperature 0 with a single run (acknowledged in §4), and no variability measures are reported, it is unclear whether these margins are statistically meaningful. The authors note that 'performance trends and relative rankings remain consistent across datasets' (§4), but consistency of ranking across datasets does not address within-dataset run-to-run variability. At minimum, the paper should report results over multiple runs (e.g., 3–5 runs) with standard deviations, or explicitly temper the significance claims for margins under ~5 points.
§3.1.2 and Table 2: The experimental design partially controls for the LLM-backbone confound by running OptiAgent on both Claude Sonnet 4.5 and GPT-5.4, and by comparing against prompted baselines using the same backbones. However, the comparison against external methods (ORLM, LLMOPT, ORThought, NEMO, CoE) involves different model backbones and training procedures, and the SA values are drawn from different papers (§3.3). The paper should clarify which comparisons are backbone-controlled (same LLM, same five-element formulation) versus cross-system, and frame the 'state-of-the-art' claims accordingly. The current presentation in Table 2 mixes these without distinction, which could mislead readers about the source of improvement.

minor comments (10)

Table 2: The 'w/o' label is used for the no-system-prompt baseline but is not defined in the table caption or the main text at first appearance. Please add a clear definition.
Table 2: Some percentage values have inconsistent decimal formatting (e.g., '72.297%' for GPT-5.2 on IndustryOR vs. '72.29%' elsewhere, and '15.58 %' with a space for ORLM on LogiOR). Formatting should be consistent.
Table 2: The LLMOPT entry for LogiOR (18.48%) appears to be from a run conducted by the authors (§3.3), while other LLMOPT values are from the original paper. This should be noted in the table or caption.
§3.2: 'NLP4P' appears to be a typo for 'NLP4LP' in the dataset description paragraph.
§3.4.1: 'Our framework processed all NLP4LP 263 problems' — Table 1 lists NLP4LP as 262 problems. Please reconcile.
§3.4.1: 'achieving a rate of 87 of 263 loops per problem' is awkwardly phrased. Table 3 clarifies that 87 of 263 problems triggered loops, but the text should state this directly.
Figure 1: The feedback loop labels (Loop 1–4) are referenced in the text but the figure should clearly indicate which loop number corresponds to which feedback path.
§1.1: The claim that the system is 'model-agnostic' is supported by testing two LLM families, but the phrase 'generalizes effectively across different LLM families' could be strengthened by noting the specific backbones tested.
Appendix A: Only the Formulation and Validation agent prompts are provided. The other four agent prompts are not included, which limits reproducibility.
References: The citation for ORThought (Yang et al., 2026) and NEMO (Song et al., 2026) reference arXiv preprints with 2026 dates. Please verify these are correctly cited and accessible.

Simulated Author's Rebuttal

3 responses · 0 unresolved

We thank the referee for a thorough and constructive review. The referee raises three major points: (1) the attribution claim that architectural decomposition—not prompt engineering or increased compute—drives improvement lacks ablation evidence; (2) the absence of variability measures (multiple runs, standard deviations) weakens the significance of the reported gains, particularly on NLP4LP where margins are ~3–5 points; and (3) Table 2 mixes backbone-controlled comparisons with cross-system comparisons drawn from different papers, potentially misleading readers about the source of improvement. We agree with all three points and will revise the manuscript accordingly.

read point-by-point responses

Referee: §4 attribution claim ('architectural decomposition, not prompt engineering, is the key driver') is unsupported without a compute-matched control; gains could stem from increased total compute rather than multi-agent decomposition or feedback loops.

Authors: The referee is correct. The claim in §4 is presented as established when it should be presented as a hypothesis. We acknowledge two issues: (a) we lack a compute-matched single-agent control (e.g., a single-agent system allowed the same number of LLM invocations or retry attempts), and (b) we lack ablation evidence isolating the contribution of the feedback loops from the task decomposition. We will revise the manuscript as follows: First, we will reframe the attribution claim in §4 as a hypothesis rather than a conclusion, explicitly noting that the current experiments cannot distinguish architectural decomposition from increased compute budget. Second, we will add a compute-matched baseline: a single-agent system permitted the same number of LLM calls per problem as OptiAgent's average (including retry attempts), using the same backbone and five-element formulation. Third, we will conduct and report an ablation that disables the feedback loops while retaining the multi-agent pipeline, to separate the contribution of task decomposition from iterative refinement. These additions will directly address the gap the referee identifies. revision: yes
Referee: Table 2 NLP4LP column: improvement margin of ~3.3–5.5 points over strongest baseline, with temperature 0 and a single run, no variability measures—unclear if margins are statistically meaningful.

Authors: We agree. Single-run results at temperature 0 do not capture run-to-run variability, and the margins on NLP4LP (and potentially other datasets) may not be statistically meaningful without repeated trials. We will address this by running all OptiAgent configurations and the backbone-controlled baselines over 5 independent runs and reporting mean SA with standard deviations. We will also explicitly temper significance claims for margins under approximately 5 points, noting where differences fall within observed variance. We note that on IndustryOR and LogiOR, the improvement margins are substantially larger (e.g., +18.5 points over GPT-5.4 with system prompt on IndustryOR; +16.3 points on LogiOR), so we expect those gains to remain robust, but we will verify this empirically. The revised manuscript will include the multi-run results in Table 2 and discuss statistical significance where appropriate. revision: yes
Referee: Table 2 mixes backbone-controlled comparisons (same LLM, same five-element formulation) with cross-system comparisons (different backbones, training procedures, sourced from different papers) without distinction, potentially misleading readers about the source of improvement.

Authors: This is a fair and important point. The current Table 2 presentation does not distinguish between comparisons that control for the LLM backbone (our prompted baselines using the same models) and comparisons against external systems (ORLM, LLMOPT, ORThought, NEMO, CoE) that use different backbones, training data, and experimental protocols. We will revise Table 2 to clearly separate these two categories—either by splitting into two sub-tables or by adding a column indicating the comparison type (backbone-controlled vs. cross-system). We will also revise the text in §3.3 and §4 to frame 'state-of-the-art' claims accordingly, distinguishing between improvements attributable to the OptiAgent architecture (backbone-controlled) and overall leaderboard position (cross-system). This will ensure readers understand which gains come from the architecture versus from differences in model scale or training. revision: yes

Circularity Check

0 steps flagged

No circularity found; the derivation is self-contained against external benchmarks.

full rationale

The paper's central claim—that multi-agent decomposition with feedback loops improves optimization modeling accuracy—is evaluated against external ground-truth benchmarks (ComplexOR, IndustryOR, LogiOR, NLP4LP) using solving accuracy as the metric. The five-element formulation is adopted from an external source (LLMOPT, JIANG et al., 2025), and the datasets are curated by an external work (ORThought, Yang et al., 2026). No cited work appears to be authored by the present paper's authors, so there is no self-citation chain. The baselines use the same LLM backbones (GPT-5.4, Claude Sonnet 4.5) as OptiAgent, providing a controlled comparison. The absence of ablation studies isolating feedback loops from raw compute is a legitimate correctness risk (the skeptic's headline captures this well), but it is not circularity: the paper does not define its inputs in terms of its outputs, does not fit a parameter to data and then call it a prediction, and does not invoke a self-authored uniqueness theorem. The attribution claim ('architectural decomposition, not prompt engineering, is the key driver') is unsupported by ablation but is not circular—it is an empirical hypothesis tested against external benchmarks, just not tested rigorously enough.

Axiom & Free-Parameter Ledger

2 free parameters · 2 axioms · 0 invented entities

The framework introduces no new mathematical entities or physical postulates. The free parameters are standard hyperparameters (max iterations, temperature). The axioms are domain assumptions about problem representation and evaluation metrics, standard in the LLM-for-OR literature.

free parameters (2)

Max loop iterations = 3
Stated in §2: 'All loops are constrained to a maximum of three iterations.' This is a hand-tuned hyperparameter affecting performance and runtime.
LLM temperature = 0
Stated in §3.1.1: 'temperature set to 0 to produce more deterministic outputs.' A modeling choice that affects reproducibility and performance.

axioms (2)

domain assumption The five-element formulation (Sets, Parameters, Variables, Objective, Constraints) is a sufficient universal representation for the OR problems in the benchmarks.
Adopted from LLMOPT (JIANG et al., 2025) and used in §2. Assumes this decomposition captures all necessary problem structure.
domain assumption Solving accuracy (SA) — whether the generated model produces solutions matching ground truth objective values — is an adequate metric for evaluating the correctness of the modeling process.
Used in §3.3. The paper itself notes in §1 that 'a common blind spot... is generating executable code that may output the correct optimal value coming from an incorrect mathematical formulation,' yet SA is the sole metric used.

pith-pipeline@v1.1.0-glm · 12688 in / 1883 out tokens · 239269 ms · 2026-07-07T15:53:39.329772+00:00 · methodology

0 comments

read the original abstract

We propose OptiAgent, a multi-agent framework that, given a natural language description of an Operations Research problem, is able to output a solver-ready mathematical formulation as well as executable code. Our architecture prioritizes the mathematical modeling step, where dedicated agents extract structures, such as decision variables and constraints, enabling iterative self-correction. We introduce a novel multi-loop validation architecture with four specialized feedback mechanisms, each targeting a distinct failure mode such as misinterpretation, structural defects, mathematical inconsistencies, validation failures, and code errors. Alongside accuracy, our modular design improves the process of solving optimization problems by improving transparency, as each agent exposes its reasoning and feedback, making the full modeling process auditable. Our framework achieves state-of-the-art performance on 3 out of 4 benchmarks across LP, MILP, and Nonlinear Programming tasks, while remaining highly competitive on the remaining dataset.

Figures

Figures reproduced from arXiv: 2607.05346 by Adriana Laurindo Monteiro, Gabriel Mattos Langeloh, Gustavo de Oliveira Kanno, Nayse Fagundes, Priscila Louise Aguirre, Thiago Costa Rizuti da Rocha, Victor Leme Beltran.

**Figure 2.** Figure 2: An instance from IndustryOR triggered loops during validation stage. Feed [PITH_FULL_IMAGE:figures/full_fig_p010_2.png] view at source ↗

discussion (0)

Reference graph

Works this paper leans on

14 extracted references · 14 canonical work pages · 1 internal anchor

[1]

Large Language Models for Supply Chain Optimization

URLhttps://openreview.net/forum?id=9OMvtboTJg. Beibin Li, Konstantina Mellou, Bo Zhang, Jeevan Pathuri, and Ishai Menache. Large language models for supply chain optimization, 2023. URLhttps://arxiv.org/abs/ 2307.03875. OpenAI. Openai gpt-5 system card, 2025. URLhttps://arxiv.org/abs/2601.03267. Rindranirina Ramamonjison, Timothy Yu, Raymond Li, Haley Li,...

work page internal anchor Pith review Pith/arXiv arXiv doi:10.24963/ijcai.2025/1192 2023
[2]

Sets: Index sets (e.g., I = set of customers, T = time periods)

work page
[3]

Parameters: Known data/constants with numeric values and domain/indices (e.g., c_ij = cost, d_i = demand)

work page
[4]

Decision Variables: Variables to be decided, with domain specification (Binary, Integer, Continuous) and indices

work page
[5]

Objective Function: Mathematical expression to optimize (min or max); must be linear

work page
[6]

interpretation_issue

Constraints: All restrictions as linear inequalities/equalities; use auxiliary variables and Big-M for complex logic. Step 2: Apply formulation rules ------------------------------- - Follow standard OR notation (sum, for-all, etc.). - If the problem is linear (LP/MILP): avoid products between decision variables. - Use auxiliary variables and Big-M when n...

work page
[7]

Structure: indices, dimensions, quantifiers (most errors occur here)

work page
[8]

Algebra: substitute test values; check for undefined operations

work page
[9]

Completeness: all variables/parameters used; all cases covered

work page
[10]

Step 2: Run the structural checks ---------------------------------

Semantics: verify the math matches the problem description. Step 2: Run the structural checks ---------------------------------

work page
[11]

Index Quantification: Every free index must be quantified

work page
[12]

Dimensional Consistency: All terms must have compatible index structure

work page
[13]

Variable Connectivity: Every variable must appear in the objective or a constraint

work page
[14]

Algebraic Validity: Substitution must yield valid statements with no undefined operations. Step 3: Produce the validation result ------------------------------------- - Validation status: APPROVED / REJECTED - If rejected, rejection reason: FORMULATION or INTERPRETATION - List of detected issues with specific citations (constraints/variables) - Actionable...

work page

[1] [1]

Large Language Models for Supply Chain Optimization

URLhttps://openreview.net/forum?id=9OMvtboTJg. Beibin Li, Konstantina Mellou, Bo Zhang, Jeevan Pathuri, and Ishai Menache. Large language models for supply chain optimization, 2023. URLhttps://arxiv.org/abs/ 2307.03875. OpenAI. Openai gpt-5 system card, 2025. URLhttps://arxiv.org/abs/2601.03267. Rindranirina Ramamonjison, Timothy Yu, Raymond Li, Haley Li,...

work page internal anchor Pith review Pith/arXiv arXiv doi:10.24963/ijcai.2025/1192 2023

[2] [2]

Sets: Index sets (e.g., I = set of customers, T = time periods)

work page

[3] [3]

Parameters: Known data/constants with numeric values and domain/indices (e.g., c_ij = cost, d_i = demand)

work page

[4] [4]

Decision Variables: Variables to be decided, with domain specification (Binary, Integer, Continuous) and indices

work page

[5] [5]

Objective Function: Mathematical expression to optimize (min or max); must be linear

work page

[6] [6]

interpretation_issue

Constraints: All restrictions as linear inequalities/equalities; use auxiliary variables and Big-M for complex logic. Step 2: Apply formulation rules ------------------------------- - Follow standard OR notation (sum, for-all, etc.). - If the problem is linear (LP/MILP): avoid products between decision variables. - Use auxiliary variables and Big-M when n...

work page

[7] [7]

Structure: indices, dimensions, quantifiers (most errors occur here)

work page

[8] [8]

Algebra: substitute test values; check for undefined operations

work page

[9] [9]

Completeness: all variables/parameters used; all cases covered

work page

[10] [10]

Step 2: Run the structural checks ---------------------------------

Semantics: verify the math matches the problem description. Step 2: Run the structural checks ---------------------------------

work page

[11] [11]

Index Quantification: Every free index must be quantified

work page

[12] [12]

Dimensional Consistency: All terms must have compatible index structure

work page

[13] [13]

Variable Connectivity: Every variable must appear in the objective or a constraint

work page

[14] [14]

Algebraic Validity: Substitution must yield valid statements with no undefined operations. Step 3: Produce the validation result ------------------------------------- - Validation status: APPROVED / REJECTED - If rejected, rejection reason: FORMULATION or INTERPRETATION - List of detected issues with specific citations (constraints/variables) - Actionable...

work page