2602.03950v2

# Enhancing Mathematical Problem Solving in LLMs through Execution-Driven Reasoning Augmentation **Authors**: - Aditya Basarkar (North Carolina State University) - &Benyamin Tabarsi (North Carolina State University) - Tiffany Barnes (North Carolina State University) - &Dongkuan (DK) Xu (North Carolina State University) ## Abstract Mathematical problem solving is a fundamental benchmark for assessing the reasoning capabilities of artificial intelligence and a gateway to applications in education, science, and engineering where reliable symbolic reasoning is essential. Although recent advances in multi-agent LLM-based systems have enhanced their mathematical reasoning capabilities, they still lack a reliably revisable representation of the reasoning process. Existing agents either operate in rigid sequential pipelines that cannot correct earlier steps or rely on heuristic self-evaluation that can fail to identify and fix errors. In addition, programmatic context can distract language models and degrade accuracy. To address these gaps, we introduce Iteratively Improved Program Construction (IIPC), a reasoning method that iteratively refines programmatic reasoning chains and combines execution feedback with the native Chain-of-thought abilities of the base LLM to maintain high-level contextual focus. IIPC surpasses competing approaches in the majority of reasoning benchmarks on multiple base LLMs. All code and implementations are released as open source. Enhancing Mathematical Problem Solving in LLMs through Execution-Driven Reasoning Augmentation Aditya Basarkar North Carolina State University avbasark@ncsu.edu Benyamin Tabarsi North Carolina State University btaghiz@ncsu.edu Tiffany Barnes North Carolina State University tmbarnes@ncsu.edu Dongkuan (DK) Xu North Carolina State University dxu27@ncsu.edu ## 1 Introduction Mathematical reasoning, the ability to reliably solve multi-step math problems through symbolic manipulation and language-based deduction, is a necessary skill for LLM-based systems to master in order to build generally intelligent systems that can automate intellectual tasks. It is especially crucial in applications such as scientific discovery Cherian et al. (2024); Shojaee et al. (2025), optimization Huang et al. (2024); Forootani (2025); Habeeb et al. (2023), financial modeling Yao et al. (2025); Carvalho Santos et al. (2022), and education Gupta et al. (2025); Liu et al. (2025), among many others. As research advances towards enabling language models to use tools and understand abstract concepts, mathematical reasoning emerges as a benchmark for assessing their ability to combine symbolic structure with logical deduction. Advancing this capability is necessary for building AI systems that can engage in effective, applicable, and scientifically grounded reasoning. Despite substantial progress, many reasoning agents still struggle with two limitations. First, most systems lack a persistent and reliably manipulable representation of their overall reasoning state that allows them to make informed revisions of earlier steps. Once a model commits to a reasoning chain, whether expressed as text, a sequence of agentic steps, or a program, subsequent revisions are typically superficial, based on heuristic self-evaluation or nonexistent. Without an editable global reasoning state, the model cannot identify or act on contradictions, invalid computations, or revise previous steps, making it vulnerable to cascading errors Cemri et al. (2025). Second, execution-guided agents lack stabilizers against program bias, often over-prioritizing execution signals that could be logically flawed over token-level reasoning, resulting in brittle reasoning trajectories. When program outputs are used to draw conclusions, irrelevant or incorrect information may cause biased reasoning in models, reducing accuracy Shi et al. (2023); Yang et al. (2025). Existing approaches address portions of these limitations, but leave important gaps. Multi-agent systems such as Cumulative Reasoning (CR) Zhang et al. (2023) and Multi-agent Condition Mining (MACM) Lei et al. (2024) have enabled stepwise deliberation. However, their sequential structure locks their reasoning trajectory into a fixed forward direction. This rigidity prevents agents from freely revising earlier steps, making them vulnerable to cascading errors, a phenomenon identified by Cemri et al. (2025) as "inter-agent misalignment". Agents like Self-Refine Madaan et al. (2023), Reflexion Shinn et al. (2023), Tree-of-Thoughts Yao et al. (2023), and Graph-of-Thoughts Besta et al. (2024) offer self-evaluation, refinement, and backtracking capabilities, but their effectiveness is bounded by their capacity to produce accurate self-evaluations Huang et al. (2023), often resulting in unreliable refinements and trajectory selections. Program and tool-based agents such as Program of Thoughts (PoT) Chen et al. (2023), Tool Integrated Reasoning Agent (ToRA) Gou et al. (2024), Code-based Self Verification (CSV) Zhou et al. (2023), and Program-aided Language Model (PAL) Gao et al. (2023) provide deterministic signals through code execution. These programs are usually one-off artifacts and are not subjected to targeted revisions, leading to rigidity similar to that of sequential reasoning agents. Furthermore, recent studies have demonstrated that such agents, particularly those relying on program-based reasoning, are susceptible to irrelevant or misleading context, often over-incorporating flawed information into their reasoning traces and causing performance degradation Shi et al. (2023); Yang et al. (2025). To overcome these limitations, we propose Iteratively Improved Program Construction (IIPC), an agent that treats programs as explicit representations of the model’s reasoning chain. While most agents generate one-off code blocks, IIPC generates reasoning chains as programs designed for transparent inspection and evolution through informed revision. Each revision is grounded in deterministic feedback that includes information about intermediate steps, allowing the model to correct errors or inconsistencies in its reasoning and make causally informed changes. A memory of past mistakes is maintained to ensure that refinements minimize "revisit regret" and steer improvements away from failure modes rather than resampling failed programs. To preserve a high-level contextual focus, IIPC adopts a dual-branch architecture. The token-level reasoning branch produces a CoT reasoning trace free from dependence on program output, while the program-refinement branch iteratively refines an executable representation of the model’s reasoning. The outputs of the two branches are combined only at the final stage to provide context for the final reasoning chain. Through this mechanism, IIPC avoids over-reliance on potentially incorrect or irrelevant program results while leveraging relevant information. As a result, IIPC provides a unified reasoning mechanism that combines manipulable representations of reasoning traces with context-stable reasoning, overcoming the limitations of existing multi-agent, self-evaluating, and execution-guided systems. The paper’s primary contributions are as follows: 1. We introduce IIPC, a new reasoning method that is designed to refine programs through execution-guided feedback, integrate execution outputs into its own reasoning abilities, and surpass other code-based, state-of-the-art, non-ensemble reasoning agents in difficult math problem-solving benchmarks. 1. We provide the reasoning-trace corpus generated from testing IIPC, including problem statements, initial propositions, generated code, execution outputs, integrated deliberation, and final answers, to facilitate reproducible evaluation, detailed error analysis, and future work on program-centric reasoning. 1. We conduct a comprehensive evaluation of IIPC against various multi-agent reasoning methods across large language models and mathematical reasoning benchmarks. IIPC surpasses PoT, MACM, and CR on the majority of the mathematical problem-solving benchmarks on multiple base LLMs. ## 2 Related Work Recently developed multi-agent systems vary in their approach to structuring mathematical reasoning. CR Zhang et al. (2023) uses three components: a proposer, verifier, and reporter. These components generate, evaluate, and collect reasoning steps. CR achieves 72.2% accuracy on 500 MATH problems Hendrycks et al. (2021) using GPT-4 and early LLaMA models. MACM Lei et al. (2024) accumulates and verifies conditions needed to solve the given problem rather than processing the reasoning steps. MACM also uses voting mechanisms to leverage uncertainty and explore multiple reasoning trajectories that are higher in quality than CoT Wei et al. (2022), Tree-of-Thoughts (ToT) Yao et al. (2023), or Graph-of-Thoughts (GoT) Besta et al. (2024) prompting. Despite their improvements on popular benchmarks, sequential processing introduces rigid reasoning chains that cause errors to propagate over subsequent steps. While sequential multi-agent systems like MACM and CR focus on reasoning through iterative step accumulation, other research directions enhance problem-solving by integrating external tools. Tool-Integrated Reasoning Agent (ToRA) Gou et al. (2024) fine-tunes LLaMA models to interleave natural language reasoning with tool calls. PoT Chen et al. (2023) generates and executes Python programs, using the outputs to arrive at the final answer. Code-Based Self-Verification (CSV) Zhou et al. (2023) includes programmatic checks to verify and refine solutions, improving reliability through iterative code-driven validation. Other approaches aim to improve reasoning internally through self-correction. Agents like self-refine Madaan et al. (2023) and Reflexion Shinn et al. (2023) adopt an iterative self-improvement approach, generating feedback on their own output and refining it until a predefined stopping condition is met. These methods provide foundational insights for enhancing program-based reasoning, which our approach leverages and advances. IIPC’s program refinement mechanism is similar to CodePRM Li et al. (2025) in its usage of execution feedback to refine reasoning. However, IIPC treats programs as representations of the reasoning chain, whereas CodePRM edits natural-language thoughts based on their quality scores for better downstream execution. The dual-branch architecture used by IIPC conceptually resembles the Talker-Reasoner architecture Christakopoulou et al. (2024), where a talker agent performs fast language generation, the reasoner performs multi-step reasoning, and they interact through a shared memory. However, unlike the interleaved process of the Talker-Reasoner, IIPC maintains a clean CoT trace and only merges at the end to remain robust to noisy programmatic outputs. Execution-Guided Classifier-Free Guidance (EG-CFG) Lavon et al. (2025) is a decoding strategy that guides token sampling based on line-level execution. OpenCodeInterpreter (OCI) Zheng et al. (2024) uses an execution guided refinement loop to iteratively refine generated programs. Outcome-Refining Process Supervision (ORPS) Yu et al. (2025) performs a beam search over reasoning-code trajectories, selecting candidates based on execution-based outcome signals. In contrast, IIPC treats programs as representations for mathematical problem solving, refining them using both process- and outcome-level signals to identify and correct reasoning errors. ## 3 Iteratively Improved Program Construction (IIPC) <details> <summary>x1.png Details</summary>  ### Visual Description ## [System Diagram]: Program Refinement and Insight Combination Flowchart ### Overview The image is a technical flowchart illustrating a multi-stage process for program development, refinement, and insight combination. It depicts a system that takes an initial input `x`, develops and refines a program through iterative validation and error correction, and combines insights to produce a final output `y`. The diagram uses color-coded regions to group related functional components and arrows to indicate data flow and control dependencies. ### Components/Axes The diagram is organized into four primary, color-coded functional regions: 1. **Blue Region (Left): "initial program development"** * Contains a dashed box enclosing two functions. * **Input:** `x` (a circle node). * **Functions:** * `f_init` (green rectangle). * `f_prog` (red rectangle). * **Flow:** `x` feeds into both `f_init` and `f_prog`. The output of `f_prog` flows to the central green region. 2. **Gray Region (Bottom-Left): "token-based reasoning"** * Contains a single function: `f_cot` (yellow rectangle). * **Flow:** Receives input from `x` (via a downward arrow). Its output flows to the orange region on the right. 3. **Green Region (Center): "program refinement"** * This is the largest region, indicating an iterative core process. * **Top Sub-block (`P_t`):** A rounded rectangle labeled `P_t` containing a sequence: `p₁`, `p₂`, ..., `p*`. This likely represents a set of program candidates or parameters at step `t`. * **Bottom Sub-block (`M_t`):** A rounded rectangle labeled `M_t` containing a sequence: `m₁`, `m₂`, ..., `mₖ`. This likely represents a set of models, metrics, or memory items at step `t`. * **Central Functions (within a dashed box):** * `f_val` (purple rectangle): Validation function. * `f_err` (pink rectangle): Error function. * **Flow:** The output from `f_prog` (blue region) enters this region. There are complex, bidirectional feedback loops: * `P_t` and `M_t` both feed into `f_val` and `f_err`. * `f_val` and `f_err` have outputs that loop back to update `P_t` and `M_t`. * The refined output from this region flows to the orange region. 4. **Orange Region (Right): "insight combination"** * Contains a single function: `f_comb` (cyan rectangle). * **Inputs:** Receives data from two sources: 1. The main flow from the green "program refinement" region. 2. The output from `f_cot` in the gray "token-based reasoning" region. * **Output:** Produces the final result `y` (a circle node). ### Detailed Analysis The diagram describes a closed-loop, iterative system for program synthesis or improvement. * **Initial Phase:** The process begins with input `x`. The `f_init` function likely creates an initial program state, while `f_prog` generates the first program version. Concurrently, `f_cot` performs a separate "chain-of-thought" reasoning process on the same input `x`. * **Refinement Loop:** The core is the green region. The program candidate set `P_t` and the model/metric set `M_t` are evaluated by `f_val` (validation) and `f_err` (error calculation). The results of this evaluation are used to update `P_t` and `M_t`, creating an iterative refinement cycle. The arrows suggest that both the program parameters and the evaluation models are updated based on validation and error signals. * **Final Combination:** The refined program output and the independent reasoning trace from `f_cot` are merged by the `f_comb` function. This suggests the system combines structured program refinement with a separate reasoning pathway to produce the final output `y`. ### Key Observations 1. **Iterative Core:** The central green region is the most complex, with multiple feedback loops, highlighting that program refinement is an iterative, not a one-pass, process. 2. **Parallel Processing:** The system runs two parallel paths from the start: the main program development path (blue -> green) and a separate token-based reasoning path (gray). These paths converge only at the final combination stage. 3. **Dual Update Mechanism:** Within the refinement loop, both the program set (`P_t`) and the model/metric set (`M_t`) are updated, indicating the system may be co-adapting the solution and its evaluation criteria. 4. **Clear Functional Separation:** Each colored region has a distinct, labeled purpose, making the high-level architecture easy to follow despite the internal complexity of the refinement loop. ### Interpretation This diagram represents a sophisticated **iterative program synthesis or repair system**. The key insight is that effective program generation isn't a single step but a cycle of proposal (`f_prog`), evaluation (`f_val`, `f_err`), and update (`P_t`, `M_t`). The inclusion of a separate "token-based reasoning" (`f_cot`) pathway suggests the system leverages both formal program manipulation and a more flexible, perhaps language-model-based, reasoning process. The final `f_comb` function acts as a fusion layer, integrating the strengths of both approaches. This architecture is typical of modern AI systems that combine symbolic program search with neural network-based reasoning and evaluation to solve complex tasks. The "uncertainty" in this context is not numerical but architectural; the exact algorithms for `f_val`, `f_err`, and the update rules for `P_t`/`M_t` are abstracted away, representing the core research challenges of such a system. </details> Figure 1: Overview of IIPC. $f_{\text{init}}$ derives key propositions from the problem statement; $f_{\text{prog}}$ generates an initial candidate program; $f_{\text{val}}$ evaluates program correctness and logical consistency; if errors are detected, the error correction component $f_{\text{err}}$ revises the program accordingly; $f_{\text{cot}}$ produces a textual chain of thought; $f_{\text{comb}}$ combines program and token reasoning context for final output; $M_{t}$ denotes the error descriptor memory at refinement step $t$ ; $P_{t}$ represents the program store at step $t$ . Our proposed method, IIPC, introduces an execution-guided reasoning methodology that directly addresses the limitations of works previously mentioned. Rather than accumulating steps or conditions sequentially, as in CR and MACM, IIPC develops programs that solve the given problem while simultaneously storing compact failure descriptors. This allows IIPC to iteratively converge toward correct solutions while dynamically avoiding previously failed reasoning paths. IIPC begins by using a model $f$ for developing a set of initial propositions $s$ ( $s=f_{init}(x)$ ), which are statements derived explicitly from the given problem $x$ , as well as additional information needed to solve the problem. These statements encapsulate all critical information, whether explicitly provided by the problem or implicitly required, to guide subsequent solution steps. Given the problem statement and the set of initial propositions, IIPC generates a candidate solution program $p_{1}$ ( $p_{1}=f_{prog}(x,s)$ ) that transparently represents its reasoning process. Every generated program conforms to the following constraints: - Programs must be restricted to the following libraries: numpy, math, sympy, scipy, and scikit-spatial. These libraries are sufficient to express the vast majority of mathematical reasoning tasks. Additionally, they are stable, widely used, and deterministic, minimizing variability across runs. - To facilitate debugging, the program must avoid using any list comprehensions or recursion and should make use of print statements. - Comments must be verbose and descriptive for aiding correction and refinement. - The program must include a section that verifies the final answer, allowing the framework to evaluate its correctness. Once the program is constructed, it is executed using an interpreter $E$ to yield an output ( $o_{1}=E(p_{1})$ ), which can either be the program’s output, an error, or both. This serves as the basis for subsequent reflection and refinement. IIPC reviews the generated program’s reasoning and consults a persistent reflection memory containing past mistakes ( $M_{t}$ , where $t$ is the time point of the current refinement step) to avoid repeating unsuccessful strategies. It then either (1) issues a revised program accompanied by a concise reflection on the identified flaw, which is logged in the memory store before the revised program is re-executed, or (2) outputs a stopping signal indicating that the current program and its outputs are satisfactory for solving the problem without further refinement. If the program produces an error, IIPC amends only the offending code segment without modifying the reasoning chain itself. It also produces a concise reflection on the mistake, which is appended to its memory store for guiding future iterations. IIPC iteratively refines the design by executing a series of process validations and error corrections to produce the optimal program for solving the given problem. If a program does not result in an error, the process validation component will assess the program’s validity and its output. However, if the program produces an error, the error correction component will revise it while preserving the reasoning chain. The resulting programs from either process are rerun and cycled (along with their output and error) back into one of the two components for further correction and/or enhancement. The current implementation for refinement, as tested in the main experiments, allows a maximum of two process validations and two error corrections after each process validation. All working programs and their output are stored in an array $P_{t}$ , with the program with the highest index being the most recently developed working program. This back-and-forth loop between the process validation and error-correction components continues until a stop condition is met. The stop condition could either be a satisfactory program, a limit on the allowed number of refinements or error corrections, or a limit on the token usage of the agent. Formally, this refinement process can be summarized in the following formulas: $$ \displaystyle(p_{t+1},m_{t+1}) \displaystyle=\begin{cases}f_{err}(x,s,p_{t},o_{t},M_{t}),&\text{if }o_{t}\in e,\\[4.0pt] f_{val}(x,s,p_{t},o_{t},M_{t}),&\text{if }o_{t}\notin e\end{cases} \displaystyle M_{t+1} \displaystyle=M_{t}\cup m_{t+1} \displaystyle P_{t+1} \displaystyle=P_{t}\cup p_{t}\ \ \text{if}\ \ o_{t}\notin e \tag{1} $$ where $m_{t+1}$ is an error or mistake descriptor, $f_{err}$ is the function that corrects errors, and $f_{ref}$ is the refinement function that can result in a $\emptyset$ for both $p_{t+1}$ and $m_{t+1}$ if the refinement process reaches a stopping point. In addition to program construction and refinement, IIPC generates a purely text-based CoT $c$ in a separate branch and arrives at a temporary answer ( $c=f_{cot}(x,s)$ ). The most recent working program ( $p^{\star}\in P_{t}$ ) and its output ( $o^{\star}$ ) with the generated CoT ( $c$ ) text is concatenated through a structured integration prompt, which is used as input to the underlying LLM to arrive at the final answer for the problem ( $y=f_{comb}(x,s,p^{\star},o^{\star},c)$ ). This step allows IIPC to reevaluate the solution using symbolic evidence from both refined program execution and native linguistic reasoning, thereby reducing over-dependence on a single kind of context. ## 4 Experiments #### Experimental Setup. Our evaluation benchmarks the IIPC framework on two mathematical reasoning datasets: (1) MATH Hendrycks et al. (2021), comprising complex problems in multiple subjects with five difficulty levels; (2) and AIME (American Invitational Mathematics Examination) Veeraboina (2024), consisting of difficult competition math problems from 1983 to 2024 that emphasize creative problem solving and is more challenging than the MATH dataset. For the MATH dataset, we evaluate on a balanced subset of the official test split from the original dataset, targeting uniform coverage across all topic-difficulty combinations (35 bins total). Due to limited availability in certain bins, the final subset contained 1483 problems total. For the AIME dataset Veeraboina (2024), we use the complete set of 933 problems spanning the years 1983-2024. We compare IIPC’s performance against other reasoning paradigms, including CR Zhang et al. (2023), MACM Lei et al. (2024), and PoT prompting Chen et al. (2023). We evaluate across multiple state-of-the-art LLMs, including GPT-4o mini, Gemini 2.0 Flash, Mistral Small 3.2 24B, Gemma 3 27B, and Llama 4 Maverick, to characterize how model architecture influences accuracy. Finally, our ablations isolate the contributions of specific architectural components, examine the effect of varying decoding temperatures, evaluate all methods under voting-based aggregation, and use GSM8K Cobbe et al. (2021), a data set consisting of grade school math problems, to assess performance degradation due to agentic overhead on simpler math problems. #### Agent Implementations. For the purposes of this study, the main evaluation tests all prompting-based reasoning agents with access to code interpreters, excluding multi-trajectory aggregation (voting) mechanisms due to their high token usage and costs. To comply with this constraint, reasoning agents like MACM Lei et al. (2024), which utilize and aggregate multiple answers, are adapted to operate within a single run and evaluated accordingly. While this may handicap the MACM agent, which is designed to operate in an ensemble environment, testing its performance in these conditions allows for a fair comparison with other such agents and provides insights into the weaknesses of processing steps sequentially rather than in parallel. As mentioned before, a separate ablation is provided to assess the effects of voting environments on the performance of all agents. Our implementation of PoT includes an error-correction loop that retries program generation when execution fails, until it reaches a fixed retry limit and has to fall back to standard Chain-of-Thought reasoning. This design allows us to better compare the mathematical reasoning capabilities of agents against PoT while controlling for coding ability. Our custom implementations of MACM and CR attempt to incorporate as much of the original implementations as possible and follow the proposed methods closely (with the exception of the voting mechanism for MACM). All agents are tested with an LLM decoding temperature of 0.1 and measure performance as accuracy (the number of correctly solved questions divided by the total number of questions evaluated). #### Assessing Correctness. To assess answer correctness, we first use deterministic equivalence and fall back to LLM-based judging using the LLaMA 4 Maverick model if necessary. Although deterministic evaluation is ideal, code-centric agents may produce equivalent answers in differing formats (e.g., 1.4142 versus $\sqrt{2}$ ). To ensure transparency and reproducibility, we fix the decoding temperature at 0 for the LLM judge and release the full judging code. On the AIME dataset, 97.78% of answers were verified via exact integer matching. On the MATH dataset, 72.85% of the generated answers were deterministically verified; LLM judging was only used to confirm whether the answers were incorrect after deterministic judging failed. On GSM8K, 89.35% of the answers were verified using exact answer matching. #### Other Considerations. While our evaluations focus on accuracy and tend to favor reasoning stability over token efficiency, we do recognize the fundamental limitation that IIPC incurs significant token costs by regenerating refined or corrected programs with every iteration. Additionally, our evaluation reports single-run accuracy on fixed benchmarks. However, while gains may be small for some evaluations, IIPC consistently outperforms other agents across all LLMs and datasets, reducing the likelihood that performance gains are due to noise. Table 1: Accuracy (%) of reasoning methods across five LLMs. IIPC row is shaded; bold teal = per-column SOTA. Numbers in parentheses show $\Delta$ vs PoT baseline. MATH Reasoning System GPT-4o-mini Gemini 2.0 Flash Mistral 3.2 24B Gemma 3 27B Llama 4 Maverick PoT 81.19 92.58 89.62 89.01 88.94 CR 76.53 (-4.66) 90.09 (-2.49) 83.61 (-6.01) 87.05 (-1.96) 89.94 (+1.00) MACM 72.62 (-8.57) 90.09 (-2.49) 82.13 (-7.49) 86.72 (-2.29) 88.67 (-0.27) IIPC 80.98 (-0.21) 94.13 (+1.55) 90.83 (+1.21) 90.56 (+1.55) 91.23 (+2.29) AIME Reasoning System GPT-4o-mini Gemini 2.0 Flash Mistral 3.2 24B Gemma 3 27B Llama 4 Maverick PoT 31.40 59.16 48.12 46.20 62.49 CR 23.90 (-7.50) 53.48 (-5.68) 40.09 (-8.03) 41.69 (-4.51) 62.17 (-0.32) MACM 17.79 (-13.61) 51.98 (-7.18) 37.62 (-10.50) 41.69 (-4.51) 62.17 (-0.32) IIPC 29.05 (-2.35) 64.20 (+5.04) 52.52 (+4.40) 50.48 (+4.28) 69.77 (+7.28) <details> <summary>x2.png Details</summary>  ### Visual Description ## Grouped Bar Chart: Llama 4 Maverick Accuracy by Difficulty Level ### Overview This image is a grouped bar chart titled "Llama 4 Maverick." It displays the accuracy performance of four different methods (PoT, CR, MACM, IIPC) across five increasing difficulty levels. The chart shows a clear trend of decreasing accuracy for all methods as the difficulty level increases. ### Components/Axes * **Chart Title:** "Llama 4 Maverick" (centered at the top). * **Y-Axis:** Labeled "Accuracy". The scale runs from 0.0 to 1.0, with major gridlines at 0.0, 0.2, 0.4, 0.6, 0.8, and 1.0. * **X-Axis:** Labeled "Difficulty Level". It contains five discrete categories: 1, 2, 3, 4, and 5. * **Legend:** Positioned at the bottom center of the chart. It defines four data series by color: * **Blue:** PoT * **Orange:** CR * **Green:** MACM * **Red:** IIPC * **Data Labels:** Each bar has its exact accuracy value printed vertically inside it. ### Detailed Analysis The chart presents accuracy values for each method at each difficulty level. The data is as follows: **Difficulty Level 1:** * PoT (Blue): 95.34 * CR (Orange): 95.70 * MACM (Green): 96.06 * IIPC (Red): 96.06 * *Trend:* All methods perform very similarly, with accuracy clustered tightly between ~95.3 and 96.1. **Difficulty Level 2:** * PoT (Blue): 96.68 * CR (Orange): 96.68 * MACM (Green): 95.68 * IIPC (Red): 96.68 * *Trend:* Performance remains high. PoT, CR, and IIPC are tied at the highest value. MACM is slightly lower. **Difficulty Level 3:** * PoT (Blue): 92.36 * CR (Orange): 91.36 * MACM (Green): 92.03 * IIPC (Red): 93.69 * *Trend:* A noticeable drop in accuracy for all methods compared to levels 1 and 2. IIPC shows the highest accuracy. **Difficulty Level 4:** * PoT (Blue): 86.71 * CR (Orange): 87.04 * MACM (Green): 87.71 * IIPC (Red): 89.37 * *Trend:* Accuracy continues to decline for all series. IIPC maintains a lead of approximately 1.6-2.7 points over the others. **Difficulty Level 5:** * PoT (Blue): 74.09 * CR (Orange): 74.42 * MACM (Green): 72.43 * IIPC (Red): 80.73 * *Trend:* The most significant drop occurs here. IIPC demonstrates a clear performance advantage, being the only method to remain above 80% accuracy. MACM shows the lowest performance. ### Key Observations 1. **Universal Performance Degradation:** All four methods (PoT, CR, MACM, IIPC) exhibit a consistent downward trend in accuracy as the difficulty level increases from 1 to 5. 2. **IIPC Superiority:** The IIPC method (red bars) consistently achieves the highest or tied-for-highest accuracy at every single difficulty level. Its advantage becomes most pronounced at the highest difficulty (Level 5), where it outperforms the next best method (CR) by over 6 percentage points. 3. **MACM Vulnerability:** The MACM method (green bars) tends to be the lowest-performing or among the lowest at higher difficulties, showing the sharpest decline at Level 5 (72.43). 4. **Clustering at Low Difficulty:** At Difficulty Levels 1 and 2, the performance of all four methods is very tightly clustered, with differences of less than 1.5 percentage points. ### Interpretation This chart evaluates the robustness of the "Llama 4 Maverick" system (or components thereof) under increasing task difficulty. The data suggests that while all tested methods struggle as problems become harder, the **IIPC method is the most robust and scalable**, maintaining a significant performance buffer at the highest difficulty tier. The near-identical performance at low difficulty levels indicates that for simple tasks, the choice of method may be less critical. However, for complex applications, employing the IIPC approach would likely yield the best results. The consistent ranking (IIPC > others, with MACM often trailing) provides a clear hierarchy of method effectiveness for this specific evaluation. </details> Figure 2: Accuracy of PoT, IIPC, CR, and MACM on the MATH dataset using Llama 4 Maverick. This bargraph is stratified by difficulty level <details> <summary>x3.png Details</summary>  ### Visual Description ## Heatmap: Llama 4 Maverick Performance Across Math Categories and Evaluation Methods ### Overview This image is a heatmap titled "Llama 4 Maverick," displaying the performance scores (presumably percentages) of an AI model named "Llama 4 Maverick" across seven mathematical categories and four different evaluation methods. The performance is visualized using a color gradient from green (lower scores) to yellow (higher scores). ### Components/Axes * **Title:** "Llama 4 Maverick" (centered at the top). * **Row Labels (Y-axis - Math Categories):** Listed vertically on the left side. From top to bottom: 1. Algebra 2. Count. & Prob. (Counting & Probability) 3. Geometry 4. Inter. Algebra (Intermediate Algebra) 5. Number Theory 6. Prealgebra 7. Precalculus * **Column Labels (X-axis - Evaluation Methods):** Listed horizontally at the bottom. From left to right: 1. PoT 2. CR 3. MACM 4. IIPC * **Data Grid:** A 7x4 grid of colored cells, each containing a numerical score. * **Color Scale/Legend:** A gradient bar is not explicitly shown, but the cells themselves form a visual legend. Colors range from a darker green (associated with lower scores, e.g., 75.24) to a bright yellow (associated with higher scores, e.g., 98.60). The legend is implicitly embedded in the data grid's color mapping. ### Detailed Analysis **Data Table Reconstruction:** The following table lists all extracted scores. Rows represent Math Categories, and columns represent Evaluation Methods. | Math Category | PoT | CR | MACM | IIPC | |--------------------|--------|--------|--------|--------| | Algebra | 95.81 | 97.21 | 98.14 | 98.60 | | Count. & Prob. | 91.00 | 91.00 | 92.42 | 91.47 | | Geometry | 79.52 | 80.00 | 75.24 | 80.48 | | Inter. Algebra | 83.72 | 80.00 | 84.19 | 87.44 | | Number Theory | 91.09 | 94.06 | 91.09 | 94.06 | | Prealgebra | 94.42 | 95.35 | 94.42 | 96.74 | | Precalculus | 86.98 | 85.12 | 85.12 | 89.77 | **Trend Verification & Color Correlation:** * **Algebra:** Scores are consistently high (95.81 to 98.60), represented by bright yellow cells. The trend is slightly upward from PoT to IIPC. * **Count. & Prob.:** Scores are stable in the low 90s (91.00 to 92.42), shown in yellow-green. * **Geometry:** Scores are the lowest overall (75.24 to 80.48), represented by the darkest green cells. The MACM score (75.24) is a notable low point. * **Inter. Algebra:** Scores are in the mid-80s (80.00 to 87.44), shown in green to yellow-green. There is a dip at CR (80.00). * **Number Theory:** Scores are in the low-to-mid 90s (91.09 to 94.06), shown in yellow-green. PoT and MACM have identical scores (91.09), as do CR and IIPC (94.06). * **Prealgebra:** Scores are high (94.42 to 96.74), shown in yellow. PoT and MACM have identical scores (94.42). * **Precalculus:** Scores are in the mid-to-high 80s (85.12 to 89.77), shown in green to yellow-green. CR and MACM have identical scores (85.12). ### Key Observations 1. **Category Performance Spread:** There is a significant performance gap between categories. Algebra is the strongest (peak: 98.60), while Geometry is the weakest (low: 75.24). 2. **Evaluation Method Consistency:** The IIPC method generally yields the highest or tied-for-highest scores in 6 out of 7 categories (all except Count. & Prob., where it is second). The CR method often yields the lowest or tied-for-lowest scores. 3. **Identical Scores:** Several pairs of identical scores appear across different evaluation methods for the same category (e.g., Number Theory: PoT=MACM=91.09; Precalculus: CR=MACM=85.12). 4. **Color Gradient Accuracy:** The color coding accurately reflects the numerical values. The brightest yellow cells correspond to the highest scores (e.g., Algebra-IIPC: 98.60), and the darkest green cells correspond to the lowest scores (e.g., Geometry-MACM: 75.24). ### Interpretation This heatmap provides a comparative performance analysis of the "Llama 4 Maverick" model. The data suggests the model has a strong grasp of foundational and algebraic mathematics (Algebra, Prealgebra, Number Theory) but struggles more with spatial and geometric reasoning (Geometry). The performance in Intermediate Algebra and Precalculus is moderate. The variation across evaluation methods (PoT, CR, MACM, IIPC) indicates that the model's measured proficiency is sensitive to the testing framework. The IIPC method appears to be the most favorable for this model, while CR and MACM are often more challenging. The presence of identical scores across methods for certain categories might suggest a performance ceiling or a specific limitation in the model's understanding of those topics that different evaluation techniques are equally unable to probe beyond. **Language Declaration:** All text in the image is in English. </details> Figure 3: Heatmap of accuracy (%) by subject area on the MATH benchmark for Llama-4-Maverick. Columns correspond to reasoning agents (PoT, IIPC, CR, and MACM) and rows correspond to mathematical domains. ### 4.1 MATH The MATH benchmark includes problems across a broad spectrum of advanced topics, including number theory, geometry, algebra (from prealgebra through intermediate algebra), precalculus, and counting & probability, each presented at five increasing difficulty tiers. On this benchmark, IIPC outperformed the other reasoning methods across most LLM backbones, achieving the highest scores on Gemini 2.0 Flash (94.13%), Mistral Small 3.2 24B (90.83%), Gemma 3 27B (90.56%), and Llama 4 Maverick (91.23%). Conversely, PoT surpassed IIPC and all other methods on GPT-4o-mini (81.19%). This suggests that, in models with lower reasoning capacity, the additional complexity introduced by IIPC can become counterproductive, whereas PoT reasoning traces appear better aligned with these models’ capabilities, providing just enough scaffolding without overwhelming their reasoning bandwidth. To further analyze agent behavior on the MATH benchmark, we break down performance by difficulty level and topic. Although the main evaluation presents this analysis only for Llama 4 Maverick, analogous results for all other language models are provided in the appendix. As evident in figure 2, IIPC consistently matches or outperforms other agents as difficulty increases. On the most challenging level-5 problems, IIPC achieves an accuracy of 80.73, outperforming the next best method by 6.31 points. As shown in figure 3, we find that with the exception of Counting and Probability, IIPC achieves the highest accuracy across all domains. Most notably, we record the highest gains in Pre-calculus (+2.79%, 89.77%) and Intermediate Algebra (+3.25%, 87.44%). This provides further evidence for IIPC’s ability to solve difficult problems and its effectiveness over existing methods. ### 4.2 AIME The AIME dataset contains problems from the American Invitational Mathematics Examination from 1983 to 2024. It emphasizes creative problem-solving and is the most difficult of the 3 datasets tested. Consistent with its performance on the MATH benchmark, IIPC achieved the highest accuracy on most models, specifically Gemini 2.0 Flash (64.20%), Mistral 3.2 24B (52.52%), Gemma 3 27B (50.48%), and Llama 4 Maverick (69.77%). In contrast, PoT surpassed all other methods on GPT-4o-mini (31.40%). Similar to the results on the MATH benchmark, GPT-4o-mini may lack the reasoning capacity required to fully benefit from IIPC’s more refined loop. IIPC’s design scales well to highly challenging mathematical reasoning tasks when supported by sufficiently capable models, while PoT seems to remain more robust on models with more constrained reasoning capacity. ### 4.3 Ablation Tests Table 2: Accuracy (%) of reasoning methods on GSM8K. Bold teal = per-row SOTA. Numbers in parentheses show $\Delta$ vs CoT baseline. | LLM | CoT | IIPC | PoT | MACM | CR | | --- | --- | --- | --- | --- | --- | | GPT-4o-mini | 94.54 | 94.24 | 93.56 | 91.05 | 92.34 | | Gemini 2.0 Flash | 96.06 | 95.60 | 95.75 | 92.57 | 91.89 | | Mistral 3.2 24B | 95.22 | 95.00 | 94.84 | 93.86 | 94.47 | | Gemma 3 27B | 95.45 | 94.84 | 94.47 | 91.36 | 93.18 | | Llama 4 Maverick | 96.13 | 95.53 | 95.53 | 94.24 | 95.91 | Table 3: Ablation results on MATH (Gemini 2.0 Flash) and AIME (Gemini 2.0 Flash, GPT - 4o - mini). Best per column is bold teal. | Methods | MATH (Gemini) | AIME | | | --- | --- | --- | --- | | Gemini 2.0 Flash | Gemini 2.0 Flash | GPT-4o-mini | | | CoT | 92.92 | 56.70 | 21.11 | | PoT-NC | 92.52 | 59.12 | 31.19 | | PoT | 92.58 | 59.16 | 31.40 | | IIPC-NS-NMS | 93.19 (+0.61) | 60.77 (+1.61) | 26.90 (-4.50) | | IIPC-NS | 93.59 (+1.01) | 61.52 (+2.36) | 27.12 (-4.28) | | IIPC | 94.13 (+1.55) | 64.20 (+5.04) | 29.05 (-2.35) | Table 4: IIPC temperature ablation on AIME (Gemini 2.0 Flash). Best is bold teal. | Temperature | Accuracy (%) | | --- | --- | | 0.1 | 64.20 | | 0.3 | 64.52 | | 0.5 | 63.56 | | 0.7 | 63.13 | | 0.9 | 63.24 | Table 5: Effect of voting on MATH Level-5 (245 problems) using Llama 4 Maverick. Best in each column is bold teal. | Agent | No Voting | Voting | | --- | --- | --- | | CoT | 70.61 | 74.29 | | PoT | 73.47 | 80.30 | | CR | 68.57 | 78.37 | | MACM | 69.80 | 76.33 | | IIPC | 78.78 | 80.30 | To better understand which components of IIPC contribute most to its performance gains, we conducted a series of ablation studies on both the MATH and AIME benchmarks. The first set of ablations incrementally adds architectural features across five methods: - CoT: A baseline Chain-of-Thought method with purely token-level reasoning. - PoT-NC: A Program-of-Thoughts method that generates and executes programs but omits the correction loop. - PoT: A PoT method with both program generation and execution-guided error correction. - IIPC-NS-NMS: An IIPC variant with the full correction and iterative refinement loop but without the token-reasoning branch or persistent reflection memory. Conclusions are made directly from the programmatic context. - IIPC-NS: An IIPC variant with the full correction and iterative refinement loop without the token-reasoning branch, but with the persistent reflection store. Conclusions are made directly from the programmatic context. - IIPC: The full IIPC reasoning agent. #### Architectural Ablation Analysis. Table 3 summarizes the impact of key IIPC mechanisms across datasets and model backbones. On Gemini 2.0 Flash, the iterative refinement, reflection memory, and dual-branch separation provide substantial gains. Iterative refinement improves accuracy by +0.61% on the MATH dataset (92.58 → 93.19) and +1.61% on the AIME dataset (59.16 → 60.77). The reflection memory improves accuracy by an additional 0.4% on the MATH dataset (93.19 → 93.59) and 0.75% on the AIME dataset (60.77 → 61.52). Dual-branch separation yields an additional +0.54% on the MATH dataset (93.59 → 94.13) and +2.68% on the AIME dataset (61.52 → 64.20). Together, these mechanisms increase performance by 1.55% over PoT on the MATH dataset (92.58 → 94.13), and by 5.04% over PoT on the AIME dataset (59.16 → 64.20), highlighting their effectiveness for tasks requiring structured reasoning. On GPT-4o mini, while PoT achieves the highest accuracy, ablations show that individual IIPC components partially mitigate the performance gap. The reflection store and dual-branch separation reduce the accuracy drop of IIPC relative to PoT, even though the accuracy of the full IIPC agent remains below the PoT baseline. #### Complexity Ablation Analysis. We also compared IIPC, MACM, CR, and PoT against CoT on GSM8K, as shown in Table 2, to determine whether agent complexity hinders accuracy compared to chain of thought reasoning on easier math problems. CoT performs near the upper limit across most models, achieving 95–97% accuracy on the strongest backbones. On average, IIPC and PoT closely trail CoT’s performance, while MACM and CR have slightly lower accuracy. These results suggest that GSM8K’s problem structure saturates the benefits of iterative refinement, leaving little room for improvement beyond direct token-level reasoning on stronger models. Nonetheless, IIPC’s close performance to CoT demonstrates that its structure does not significantly degrade accuracy, even in low-complexity reasoning environments. #### Temperature Ablation Analysis. We further examined the effect of varying the decoding temperature on IIPC’s performance with Gemini 2.0 Flash on the AIME benchmark (Table 4). Across the tested range (0.1–0.9), accuracy remained relatively stable, fluctuating within a narrow band of 1.39 percentage points. The best performance was achieved at 0.3 (64.52%), while higher temperatures (0.5–0.9) yielded slightly lower accuracies (63.13%–63.56%). These results suggest that IIPC is robust to temperature changes, with only marginal sensitivity, although higher temperatures appear to slightly diminish performance. #### Voting Ablation Analysis. Beyond architectural and temperature-based variations, we also evaluate the effect of voting, a method used in the original MACM implementation, on IIPC’s performance. As detailed in the appendix, our evaluation excludes stochastic multi-trajectory aggregation due to high costs, but we isolate its effect in a smaller ablation study using Llama-4-Maverick on 245 Level-5 MATH problems (35 from each topic). To align with MACM’s original setting, we use a decoding temperature of 0.1 for the non-voting environment, 0.7 for the voting environment, a minimum of 5 voters, and a maximum of 7 voters for tie-breaking. The results in Table 5 show that without voting, IIPC achieves the highest accuracy at 78.78%, outperforming even voting-based variants of many baselines. When voting is enabled, IIPC achieves the same accuracy as PoT at 80.30%. Voting yields larger gains for PoT (+6.83%), CoT (+3.68%), CR (+9.8%), and MACM (+6.53%), while the relative improvement for IIPC (+1.52%) is smaller. IIPC exhibits smaller gains from voting, suggesting reduced single-trajectory variance compared to baselines that rely more on sampling diversity. ## 5 Conclusion In this work, we introduced Iteratively Improved Program Construction (IIPC) for mathematical reasoning with LLMs through execution-guided refinement while mitigating execution bias by reducing over-dependence on program-based context. Our experiments show that IIPC consistently delivers competitive or superior performance. On GSM8K, where simpler reasoning tasks leave limited room for improvement, IIPC demonstrated that its additional structure does not significantly hinder its reasoning capabilities compared to simpler baselines. On both the MATH and AIME datasets, IIPC achieved the highest accuracy across 4 of the 5 models tested. These results demonstrate that integrating token-based reasoning with iterative program refinement provides LLMs with valuable capacity for trajectory correction and reasoning-level regularization, reducing over-commitment to execution-conditioned context. ## 6 Limitations Despite the advantages of IIPC, our results also revealed some trade-offs. On GPT-4o mini, IIPC lagged behind PoT on both MATH and AIME. These findings suggest that while IIPC scales effectively with models capable of sustaining its iterative refinement loop, models with limited reasoning or coding abilities may instead benefit from PoT’s simpler structure. In addition, although IIPC’s design enables advanced refinement for solving difficult problems, it is a token-intensive approach to reasoning. While IIPC proves robust on GSM8K and state-of-the-art on MATH and AIME across several high-capacity models, there is room for improvement in subsequent research. Future directions include addressing token efficiency in IIPC’s design, adapting to models’ reasoning capacity, and extending IIPC to other domains requiring verifiable, structured reasoning beyond mathematics. ## 7 Ethical Considerations Our work introduces an execution-guided agent for enhanced mathematical reasoning in LLMs. The proposed method is evaluated on publicly available benchmarks (AIME, MATH, GSM8K) and does not involve human subjects, personal data, or proprietary datasets. We have ensured that none of the data used or generated by this research contains information that uniquely identifies people. While IIPC is designed to improve reasoning capabilities, it doesn’t guarantee correctness. Any outputs generated by IIPC should not be relied on without independent verification, especially in high-stakes or real-world decision-making contexts. ChatGPT was used to provide feedback on quality, assist with some grammatical refinement and articulation, and support understanding and exploration of existing mathematical concepts for framing the proposed method. However, all revisions were carefully considered and manually done. All ideas, experimental designs, analyses, and conclusions were developed by the authors, who take full responsibility for the contents of the paper. The judging agent codebase, originally written by the authors, was later enhanced with ChatGPT to improve robustness and evaluation reliability, and was reviewed and verified by the authors. The proposed method is intended for research, benchmarking, and assistive applications. It is not meant to replace human judgment or facilitate academic dishonesty. To promote transparency and reproducibility, all code, evaluations, sampled datasets, and reasoning traces generated by the proposed method are released as open source. We hope that our work will contribute positively to ongoing research in LLM reasoning. ## References - M. Besta, N. Blach, A. Kubicek, R. Gerstenberger, M. Podstawski, L. Gianinazzi, J. Gajda, T. Lehmann, H. Niewiadomski, P. Nyczyk, et al. (2024) Graph of thoughts: solving elaborate problems with large language models. In Proceedings of the AAAI conference on artificial intelligence, Vol. 38, pp. 17682–17690. Cited by: §1, §2. - G. Carvalho Santos, F. Barboza, A. Veiga, and K. Gomes (2022) Portfolio optimization using artificial intelligence: a systematic literature review. Exacta 0, pp. . External Links: Document Cited by: §1. - M. Cemri, M. Z. Pan, S. Yang, L. A. Agrawal, B. Chopra, R. Tiwari, K. Keutzer, A. Parameswaran, D. Klein, K. Ramchandran, et al. (2025) Why do multi-agent llm systems fail?. arXiv preprint arXiv:2503.13657. Cited by: §1, §1. - W. Chen, X. Ma, X. Wang, and W. W. Cohen (2023) Program of thoughts prompting: disentangling computation from reasoning for numerical reasoning tasks. External Links: 2211.12588, Link Cited by: §1, §2, §4. - A. Cherian, R. Corcodel, S. Jain, and D. Romeres (2024) LLMPhy: complex physical reasoning using large language models and world models. External Links: 2411.08027, Link Cited by: §1. - K. Christakopoulou, S. Mourad, and M. Matarić (2024) Agents thinking fast and slow: a talker-reasoner architecture. External Links: 2410.08328, Link Cited by: §2. - K. Cobbe, V. Kosaraju, M. Bavarian, M. Chen, H. Jun, L. Kaiser, M. Plappert, J. Tworek, J. Hilton, R. Nakano, C. Hesse, and J. Schulman (2021) Training verifiers to solve math word problems. arXiv preprint arXiv:2110.14168. Cited by: Appendix B, §4. - A. Forootani (2025) A survey on mathematical reasoning and optimization with large language models. External Links: 2503.17726, Link Cited by: §1. - L. Gao, A. Madaan, S. Zhou, U. Alon, P. Liu, Y. Yang, J. Callan, and G. Neubig (2023) PAL: program-aided language models. External Links: 2211.10435, Link Cited by: §1. - Z. Gou, Z. Shao, Y. Gong, yelong shen, Y. Yang, M. Huang, N. Duan, and W. Chen (2024) ToRA: a tool-integrated reasoning agent for mathematical problem solving. In The Twelfth International Conference on Learning Representations, External Links: Link Cited by: §1, §2. - A. Gupta, J. Reddig, T. Calo, D. Weitekamp, and C. J. MacLellan (2025) Beyond final answers: evaluating large language models for math tutoring. External Links: 2503.16460, Link Cited by: §1. - H. A. Habeeb, D. A. Wahab, A. H. Azman, and M. R. Alkahari (2023) Design optimization method based on artificial intelligence (hybrid method) for repair and restoration using additive manufacturing technology. Metals 13 (3). External Links: Link, ISSN 2075-4701, Document Cited by: §1. - D. Hendrycks, C. Burns, S. Kadavath, A. Arora, S. Basart, E. Tang, D. Song, and J. Steinhardt (2021) Measuring mathematical problem solving with the math dataset. NeurIPS. Cited by: Appendix B, §2, §4. - J. Huang, X. Chen, S. Mishra, H. S. Zheng, A. W. Yu, X. Song, and D. Zhou (2023) Large language models cannot self-correct reasoning yet. arXiv preprint arXiv:2310.01798. Cited by: §1. - S. Huang, K. Yang, S. Qi, and R. Wang (2024) When large language model meets optimization. External Links: 2405.10098, Link Cited by: §1. - B. Lavon, S. Katz, and L. Wolf (2025) Execution guided line-by-line code generation. External Links: 2506.10948, Link Cited by: §2. - B. Lei, Y. Zhang, S. Zuo, A. Payani, and C. Ding (2024) MACM: utilizing a multi-agent system for condition mining in solving complex mathematical problems. External Links: 2404.04735 Cited by: §1, §2, §4, §4. - Q. Li, X. Dai, X. Li, W. Zhang, Y. Wang, R. Tang, and Y. Yu (2025) CodePRM: execution feedback-enhanced process reward model for code generation. In Findings of the Association for Computational Linguistics: ACL 2025, W. Che, J. Nabende, E. Shutova, and M. T. Pilehvar (Eds.), Vienna, Austria, pp. 8169–8182. External Links: Link, Document, ISBN 979-8-89176-256-5 Cited by: §2. - B. Liu, J. Zhang, F. Lin, X. Jia, and M. Peng (2025) One size doesn’t fit all: a personalized conversational tutoring agent for mathematics instruction. External Links: 2502.12633, Link Cited by: §1. - A. Madaan, N. Tandon, P. Gupta, S. Hallinan, L. Gao, S. Wiegreffe, U. Alon, N. Dziri, S. Prabhumoye, Y. Yang, S. Gupta, B. P. Majumder, K. Hermann, S. Welleck, A. Yazdanbakhsh, and P. Clark (2023) Self-refine: iterative refinement with self-feedback. External Links: 2303.17651 Cited by: §1, §2. - F. Shi, X. Chen, K. Misra, N. Scales, D. Dohan, E. Chi, N. Schärli, and D. Zhou (2023) Large language models can be easily distracted by irrelevant context. External Links: 2302.00093, Link Cited by: §1, §1. - N. Shinn, F. Cassano, E. Berman, A. Gopinath, K. Narasimhan, and S. Yao (2023) Reflexion: language agents with verbal reinforcement learning. External Links: 2303.11366, Link Cited by: §1, §2. - P. Shojaee, K. Meidani, S. Gupta, A. B. Farimani, and C. K. Reddy (2025) LLM-sr: scientific equation discovery via programming with large language models. External Links: 2404.18400, Link Cited by: §1. - H. Veeraboina (2024) AIME problem set (1983–2024). Note: https://www.kaggle.com/datasets/hemishveeraboina/aime-problem-set-1983-2024/data Accessed October 2025 Cited by: Appendix B, §4. - J. Wei, X. Wang, D. Schuurmans, M. Bosma, F. Xia, E. Chi, Q. V. Le, D. Zhou, et al. (2022) Chain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems 35, pp. 24824–24837. Cited by: §2. - M. Yang, E. Huang, L. Zhang, M. Surdeanu, W. Wang, and L. Pan (2025) How is llm reasoning distracted by irrelevant context? an analysis using a controlled benchmark. External Links: 2505.18761, Link Cited by: §1, §1. - S. Yao, D. Yu, J. Zhao, I. Shafran, T. Griffiths, Y. Cao, and K. Narasimhan (2023) Tree of thoughts: deliberate problem solving with large language models. Advances in neural information processing systems 36, pp. 11809–11822. Cited by: §1, §2. - X. Yao, Q. Wang, X. Liu, and K. Huang (2025) Evaluating large language models for financial reasoning: a cfa-based benchmark study. External Links: 2509.04468, Link Cited by: §1. - Z. Yu, W. Gu, Y. Wang, X. Jiang, Z. Zeng, J. Wang, W. Ye, and S. Zhang (2025) Reasoning through execution: unifying process and outcome rewards for code generation. External Links: 2412.15118, Link Cited by: §2. - Y. Zhang, J. Yang, Y. Yuan, and A. C. Yao (2023) Cumulative reasoning with large language models. arXiv preprint arXiv:2308.04371. Cited by: §1, §2, §4. - T. Zheng, G. Zhang, T. Shen, X. Liu, B. Y. Lin, J. Fu, W. Chen, and X. Yue (2024) OpenCodeInterpreter: integrating code generation with execution and refinement. https://arxiv.org/abs/2402.14658. Cited by: §2. - A. Zhou, K. Wang, Z. Lu, W. Shi, S. Luo, Z. Qin, S. Lu, A. Jia, L. Song, M. Zhan, and H. Li (2023) Solving challenging math word problems using gpt-4 code interpreter with code-based self-verification. External Links: 2308.07921, Link Cited by: §1, §2. ## Appendix A Theoretical Overview ### A.1 Error Propagation in Sequential Agents Sequential reasoning agents generate solution steps in an ordered manner, where each step $s_{t}$ depends on prior steps $(s_{1},s_{2},\dots,s_{t-1})$ . We can write this as: $$ s_{t}=f(s_{1},s_{2},\dots,s_{t-1}), $$ where $f$ is the language model. Once a step $s_{n}$ , with $1\leq n\leq t-1$ , has been completed, it remains permanent and cannot be revised. As a result, the conditional probability that the next step is correct, $\mathbb{P}(s_{t}\mid s_{1:t-1})$ , reduces as errors accumulate in earlier steps. This causes initial inaccuracies to propagate through the rest of the reasoning trajectory without any opportunity for correction. ### A.2 Iterative Program Refinement and Reflection Memory Let $\mathcal{P}$ denote the set of all candidate programs and $I:\mathcal{P}\!\to\!\mathcal{O}$ be the interpreter that produces an output from a program (including errors) $o=I(p)$ . At refinement step $t$ , the agent has a memory $M_{t}$ that summarizes past mistakes or errors. The IIPC refinement operator is then $$ \displaystyle p_{t+1} \displaystyle=f_{\theta}\!\big(x,\;p_{t},\;o_{t},\;M_{t}\big) \displaystyle=\arg\min_{p\in\mathcal{N}(p_{t})}\Big(\underbrace{\mathcal{L}\!\big(I(p)\big)}_{\text{execution loss}}+\lambda\,\underbrace{\Psi\!\big(p;\,M_{t}\big)}_{\text{memory penalty}}\Big). \tag{4} $$ where $\mathcal{N}(p_{t})$ is the complete set of edits around $p_{t}$ , $o_{t}$ is the execution output at step $t$ (programmatic output and errors), $\Psi(\cdot;M_{t})\!\geq\!0$ penalizes parts of the program that $M_{t}$ should prevent, $\mathcal{L}\!\big(I(\cdot)\big)$ penalizes the output of the program for undesirable outputs, and $\lambda\!>\!0$ is a trade-off factor between fixing the current error and not repeating past mistakes. Intuitively, the language model attempts to find the next best program so that it produces desirable output and doesn’t repeat past mistakes. We do emphasize that this objective is not explicitly optimized, but rather serves as a conceptual abstraction of how execution feedback and reflection memory bias the LLM’s refinement behavior. After developing $p_{t+1}$ , the memory updates with the errors of the previous iteration as $$ M_{t+1}=M_{t}\cup\mathsf{Desc}(p_{t},I(p_{t})) $$ where $\mathsf{Desc}$ extracts failure descriptions (e.g. banned mathematical methods, reflections on minor errors, API misuse, etc) that are then appended to $M_{t}$ . ### A.3 Search and Regret in Refinement Let $\mathcal{U}(M_{t})\subset\mathcal{P}$ be the union of possible program regions avoided by the memory store of past mistakes. According to the results in table 3, where we isolate the effects of individual IIPC components, the reflection memory does improve the accuracy of the IIPC agent. Motivated by these results, we can model the LLM’s refinement behavior under the penalty function $\Psi(\cdot;M_{t})$ as follows: (1) it lowers the probability of generating programs from $\mathcal{U}(M_{t})$ , (2) it does so by at least some multiplicative factor whenever a program is a flawed, and (3) the LLM maintains diversity in its refinements to explore candidates outside $\mathcal{U}(M_{t})$ . Under these assumptions, we can qualitatively model the LLM’s refinement behavior such that if $\Psi(\cdot;M_{t})$ assigns a strictly positive penalty on $\mathcal{U}(M_{t})$ and zero otherwise, then the expected probability of revisiting blacklisted regions decreases with $t$ . As a result, the cumulative revisit regret $$ R_{T}=\sum_{t=1}^{T}\mathbf{1}\{p_{t}\in\mathcal{U}(M_{t-1})\} $$ grows sub-proportionally compared to naive refinement. Therefore, the expected per-step revisit rate decreases as memory accumulates. Intuitively, this means that each time the LLM encounters an error, the memory store shifts the probability mass away from that type of failure, making it less likely to be chosen again. Over time, the agent spends a smaller fraction of steps repeating past mistakes, while still preserving the ability to explore new refinements within the edit space $\mathcal{N}(p_{t})$ . In other words, reflection memory turns trial-and-error into trial-and-improvement, where the system learns from its entire history of failures for a given problem. ### A.4 Dual-Branch Separation The objective of the dual-branch design is to find an answer $y^{*}$ that is consistent with the information from both branches. Let $x$ denote the given problem, $p$ the refined program to solve the problem, and $o$ the output of $p$ . We can first model the reasoning behavior of the two branches in terms of the implicit distributions over candidate answers $y$ as shown: - $d_{P}(y|x,p,o)$ : The distribution over candidate answer $y$ conditioned on $x$ , $p$ , and $o$ in the execution-guided reasoning branch. - $d_{T}(y|x)$ : The distribution over candidate answer $y$ conditioned on just $x$ in the token-based reasoning branch. In order to reconcile these two potentially conflicting beliefs over the answer space, we introduce an idealized distribution $d^{*}$ that takes into account information from both branches. We also introduce a weighting factor $\alpha$ that implicitly reflects how much trust should ideally be placed on the execution-guided branch relative to the token-based reasoning branch. The distribution $d^{*}$ should remain as consistent as possible with both $d_{T}$ and $d_{P}$ , while also accounting for $\alpha$ . We can formalize this notion through a conceptual disagreement-penalized objective: $$ \displaystyle d^{*} \displaystyle=\arg\min_{d}\Big[(1-\alpha)\,D_{\mathrm{KL}}\!\big(d\,\|\,d_{T}\big) \displaystyle\qquad\quad+\alpha\,D_{\mathrm{KL}}\!\big(d\,\|\,d_{P}\big)\Big]. \tag{6} $$ where $\alpha\in[0,1]$ and $D_{\mathrm{KL}}$ is the Kullback-Leibler divergence. This objective penalizes solutions that are strongly supported by only one source of reasoning, unless that source is explicitly prioritized by $\alpha$ . Intuitively, this means that under $d^{*}$ , answers that contradict token-level logical constraints or execution-based evidence receive a low probability, while answers reinforced by both branches receive a higher probability. It is important to note that while IIPC does not explicitly compute or optimize this objective, the dual-branch design induces behavior that resembles this form of regularization. Finally, while $d^{*}$ serves as a conceptual abstraction for the ideal distribution, we ultimately want an answer $y^{*}$ that is viewed as the most consistent candidate under the reconciled distribution. This can be formalized through the following objective: $$ y^{*}\ =\ \arg\max_{y}d^{*}(y). $$ This abstraction shows how dual-branch separation stabilizes reasoning by producing answers that achieve consistency across both token-level and execution-based reasoning. ### A.5 Effects of Model Capacity on Performance Our results show IIPC is strongest on higher-capacity models (Gemini 2.0 Flash, Mistral 24B). This can be theoretically understood as an alignment between model capacity and refinement overhead. If the base LLM’s reasoning capacity is insufficient, the iterative correction signal increases cognitive load beyond what the model can process or was trained for, leading to lower accuracy. ## Appendix B Additional Experimentation Details #### Reasons for Dataset Selection. To capture a range of mathematical complexity, the main experiments evaluate IIPC on the MATH and AIME datasets, while the GSM8K dataset is used for ablation experiments to study the effects of agentic overhead on simple problems. GSM8K Cobbe et al. (2021) contains grade school arithmetic problems and serves as a low-difficulty benchmark for an ablation experiment to understand how additional complexity, such as IIPC’s refinement loop and dual-branch design, affects performance on simple tasks. The MATH dataset Hendrycks et al. (2021) provides tests for algebraic manipulation, symbolic reasoning, and multi-step logic. Finally, the AIME dataset Veeraboina (2024) evaluates on competition-level problems from 1983–2024 that require creativity, deep conceptual understanding, and nontrivial problem decomposition. Evaluating on this range of datasets allows us to analyze how IIPC scales from straightforward arithmetic reasoning to advanced, competition-grade problem solving, and to identify the conditions under which iterative refinement yields the greatest benefit. Ideally, we aimed to evaluate approximately 1,500 problems per dataset to ensure balanced statistical representation. GSM8K only contains 1319 problems in its testing set, all of which were used in the ablation study. For MATH, while we aimed for uniform coverage across all topic–difficulty combinations (35 combinations total), certain combinations contained fewer available problems. This yielded a final sample of 1,483 problems instead of the intended 1,505 (the closest multiple of 35 to 1500). Finally, the AIME dataset contained a fixed set of 933 problems spanning all available years (1983–2024), and was used in its entirety. ## Appendix C Additional Experimental Results for MATH dataset <details> <summary>x4.png Details</summary>  ### Visual Description ## [Grouped Bar Charts]: AI Model Performance Across Difficulty Levels (Four Metrics) ### Overview The image contains five grouped bar charts, each representing a different AI model (GPT-4o-mini, Gemini 2.0 Flash, Mistral Small 3.2 24B, Gemma 3 27B, Llama 4 Maverick). Each chart plots **Accuracy** (y-axis, 0.0–1.0) against **Difficulty Level** (x-axis, 1–5, categorical). Four metrics are compared: *PoT* (blue), *CR* (orange), *MACM* (green), and *IIPC* (red), as indicated by the legend at the bottom. ### Components/Axes - **X-axis**: *Difficulty Level* (1, 2, 3, 4, 5) – represents increasing task complexity. - **Y-axis**: *Accuracy* (0.0 to 1.0) – continuous scale measuring performance. - **Legend**: Four metrics with color coding: - PoT (blue) - CR (orange) - MACM (green) - IIPC (red) - **Subplots**: Five subplots, each titled with the model name (e.g., “GPT-4o-mini,” “Gemini 2.0 Flash”). ### Detailed Analysis (Per Model) #### 1. GPT-4o-mini (Top-Left) - **Difficulty 1**: PoT ≈ 0.95, CR ≈ 0.91, MACM ≈ 0.91, IIPC ≈ 0.94 - **Difficulty 2**: PoT ≈ 0.91, CR ≈ 0.87, MACM ≈ 0.87, IIPC ≈ 0.91 - **Difficulty 3**: PoT ≈ 0.84, CR ≈ 0.81, MACM ≈ 0.77, IIPC ≈ 0.86 - **Difficulty 4**: PoT ≈ 0.77, CR ≈ 0.73, MACM ≈ 0.66, IIPC ≈ 0.75 - **Difficulty 5**: PoT ≈ 0.60, CR ≈ 0.50, MACM ≈ 0.43, IIPC ≈ 0.58 - **Trend**: All metrics decline with difficulty. MACM shows the steepest drop (from ~0.91 to ~0.43), while IIPC remains relatively higher at higher difficulties. #### 2. Gemini 2.0 Flash (Top-Right) - **Difficulty 1**: PoT ≈ 0.96, CR ≈ 0.95, MACM ≈ 0.94, IIPC ≈ 0.96 - **Difficulty 2**: PoT ≈ 0.96, CR ≈ 0.95, MACM ≈ 0.95, IIPC ≈ 0.97 - **Difficulty 3**: PoT ≈ 0.93, CR ≈ 0.91, MACM ≈ 0.91, IIPC ≈ 0.95 - **Difficulty 4**: PoT ≈ 0.90, CR ≈ 0.89, MACM ≈ 0.89, IIPC ≈ 0.93 - **Difficulty 5**: PoT ≈ 0.83, CR ≈ 0.79, MACM ≈ 0.77, IIPC ≈ 0.87 - **Trend**: Gradual decline with difficulty. IIPC consistently outperforms others (e.g., Difficulty 5: IIPC ≈ 0.87 vs. PoT ≈ 0.83). #### 3. Mistral Small 3.2 24B (Middle-Left) - **Difficulty 1**: PoT ≈ 0.97, CR ≈ 0.92, MACM ≈ 0.92, IIPC ≈ 0.96 - **Difficulty 2**: PoT ≈ 0.94, CR ≈ 0.91, MACM ≈ 0.90, IIPC ≈ 0.94 - **Difficulty 3**: PoT ≈ 0.94, CR ≈ 0.88, MACM ≈ 0.83, IIPC ≈ 0.90 - **Difficulty 4**: PoT ≈ 0.87, CR ≈ 0.80, MACM ≈ 0.76, IIPC ≈ 0.83 - **Difficulty 5**: PoT ≈ 0.76, CR ≈ 0.66, MACM ≈ 0.63, IIPC ≈ 0.80 - **Trend**: All metrics decrease with difficulty. MACM has a notable drop (from ~0.92 to ~0.63), while IIPC remains competitive (e.g., Difficulty 5: IIPC ≈ 0.80 vs. PoT ≈ 0.76). #### 4. Gemma 3 27B (Middle-Right) - **Difficulty 1**: PoT ≈ 0.97, CR ≈ 0.95, MACM ≈ 0.95, IIPC ≈ 0.95 - **Difficulty 2**: PoT ≈ 0.96, CR ≈ 0.95, MACM ≈ 0.94, IIPC ≈ 0.96 - **Difficulty 3**: PoT ≈ 0.93, CR ≈ 0.91, MACM ≈ 0.90, IIPC ≈ 0.95 - **Difficulty 4**: PoT ≈ 0.89, CR ≈ 0.83, MACM ≈ 0.83, IIPC ≈ 0.87 - **Difficulty 5**: PoT ≈ 0.75, CR ≈ 0.70, MACM ≈ 0.71, IIPC ≈ 0.79 - **Trend**: Gradual decline. IIPC is consistently high (e.g., Difficulty 5: IIPC ≈ 0.79 vs. PoT ≈ 0.75). #### 5. Llama 4 Maverick (Bottom) - **Difficulty 1**: PoT ≈ 0.95, CR ≈ 0.95, MACM ≈ 0.95, IIPC ≈ 0.98 - **Difficulty 2**: PoT ≈ 0.96, CR ≈ 0.95, MACM ≈ 0.95, IIPC ≈ 0.96 - **Difficulty 3**: PoT ≈ 0.92, CR ≈ 0.91, MACM ≈ 0.92, IIPC ≈ 0.93 - **Difficulty 4**: PoT ≈ 0.89, CR ≈ 0.87, MACM ≈ 0.87, IIPC ≈ 0.89 - **Difficulty 5**: PoT ≈ 0.74, CR ≈ 0.74, MACM ≈ 0.72, IIPC ≈ 0.80 - **Trend**: All metrics decline with difficulty. IIPC is the highest at Difficulty 5 (≈0.80), while MACM is the lowest (≈0.72). ### Key Observations - **Metric Robustness**: *IIPC* (red) consistently outperforms or matches other metrics across most models and difficulty levels, especially at higher difficulties. *MACM* (green) often shows the steepest decline with increasing difficulty. - **Model Resilience**: Gemini 2.0 Flash and Llama 4 Maverick maintain relatively high accuracy across difficulties, while GPT-4o-mini shows a more pronounced drop at higher difficulties. - **Difficulty Impact**: All models exhibit a clear trend of decreasing accuracy with increasing difficulty, indicating task complexity negatively impacts performance across all metrics and models. ### Interpretation The data suggests **task difficulty is a critical factor** in AI model performance, with accuracy declining as difficulty increases. The *IIPC* metric appears more robust to complexity, making it a reliable measure for challenging tasks. Models like Gemini 2.0 Flash and Llama 4 Maverick demonstrate better resilience, suggesting they may be better suited for complex problems. The consistent decline in *MACM* across models indicates it is particularly sensitive to task complexity, which could help identify models that struggle with harder tasks. This analysis highlights the importance of evaluating AI models across multiple metrics and difficulty levels to understand their strengths and limitations in real-world scenarios. </details> Figure 4: Accuracy by difficulty level for each LLM, comparing PoT, CR, MACM, and IIPC agents on the MATH dataset. <details> <summary>x5.png Details</summary>  ### Visual Description ## Accuracy Heatmaps for AI Models on Math Topics ### Overview The image displays five heatmaps (color-coded accuracy tables) for different AI models, evaluating performance across seven math topics using four methods. A color scale (0–100% accuracy) is provided, with purple for low accuracy and yellow for high. ### Components/Axes - **Models**: Five models, each with a table: - GPT-4o-mini (top-left) - Gemini 2.0 Flash (top-right) - Mistral Small 3.2 24B (middle-left) - Gemma 3 27B (middle-right) - Llama 4 Maverick (bottom) - **Rows (Math Topics)**: Algebra, Count. & Prob., Geometry, Inter. Algebra, Number Theory, Prealgebra, Precalculus (vertical axis for each table). - **Columns (Methods)**: PoT, CR, MACM, IIPC (horizontal axis for each table). - **Color Scale**: Bottom of the image, gradient from purple (0%) to yellow (100%), labeled *“Accuracy (%)”*. ### Detailed Analysis (Per Model) #### GPT-4o-mini | Topic | PoT | CR | MACM | IIPC | |----------------|--------|--------|--------|--------| | Algebra | 94.88 | 91.16 | 89.30 | 95.35 | | Count. & Prob. | 82.46 | 77.25 | 75.83 | 81.04 | | Geometry | 68.57 | 62.86 | 63.81 | 67.62 | | Inter. Algebra | 73.95 | 63.26 | 60.00 | 72.09 | | Number Theory | 85.15 | 88.61 | 74.75 | 85.64 | | Prealgebra | 90.70 | 90.23 | 87.38 | 93.02 | | Precalculus | 72.56 | 62.79 | 57.67 | 72.09 | #### Gemini 2.0 Flash | Topic | PoT | CR | MACM | IIPC | |----------------|--------|--------|--------|--------| | Algebra | 98.14 | 97.21 | 96.73 | 99.53 | | Count. & Prob. | 93.36 | 88.15 | 89.10 | 92.89 | | Geometry | 84.76 | 79.52 | 77.14 | 84.29 | | Inter. Algebra | 91.63 | 89.30 | 88.37 | 91.16 | | Number Theory | 92.08 | 96.04 | 95.05 | 98.51 | | Prealgebra | 96.28 | 94.42 | 94.42 | 97.67 | | Precalculus | 91.63 | 86.05 | 90.23 | 94.88 | #### Mistral Small 3.2 24B | Topic | PoT | CR | MACM | IIPC | |----------------|--------|--------|--------|--------| | Algebra | 97.67 | 95.35 | 96.28 | 96.28 | | Count. & Prob. | 91.00 | 80.57 | 81.99 | 91.00 | | Geometry | 80.00 | 71.90 | 70.95 | 82.38 | | Inter. Algebra | 86.51 | 78.14 | 78.14 | 88.84 | | Number Theory | 96.53 | 92.08 | 88.61 | 94.55 | | Prealgebra | 93.02 | 90.70 | 91.16 | 94.88 | | Precalculus | 82.79 | 76.74 | 67.91 | 87.91 | #### Gemma 3 27B | Topic | PoT | CR | MACM | IIPC | |----------------|--------|--------|--------|--------| | Algebra | 98.14 | 97.21 | 97.67 | 98.60 | | Count. & Prob. | 87.20 | 82.94 | 82.46 | 86.26 | | Geometry | 81.90 | 78.10 | 76.19 | 82.38 | | Inter. Algebra | 83.72 | 82.79 | 82.79 | 88.37 | | Number Theory | 91.09 | 90.59 | 93.07 | 97.03 | | Prealgebra | 94.42 | 94.88 | 92.56 | 96.28 | | Precalculus | 86.51 | 82.79 | 82.33 | 85.12 | #### Llama 4 Maverick | Topic | PoT | CR | MACM | IIPC | |----------------|--------|--------|--------|--------| | Algebra | 95.81 | 97.21 | 98.14 | 98.60 | | Count. & Prob. | 91.00 | 91.00 | 92.42 | 91.47 | | Geometry | 79.52 | 80.00 | 75.24 | 80.48 | | Inter. Algebra | 83.72 | 80.00 | 84.19 | 87.44 | | Number Theory | 91.09 | 94.06 | 91.09 | 94.06 | | Prealgebra | 94.42 | 95.35 | 94.42 | 96.74 | | Precalculus | 86.98 | 85.12 | 85.12 | 89.77 | ### Key Observations - **High-Accuracy Topics**: Algebra and Prealgebra consistently show high accuracy (e.g., Gemini 2.0 Flash’s Algebra IIPC=99.53, Llama 4 Maverick’s Prealgebra IIPC=96.74). - **Low-Accuracy Topics**: Geometry and Precalculus often have lower accuracy (e.g., GPT-4o-mini’s Geometry CR=62.86, Mistral Small’s Precalculus MACM=67.91). - **Method Performance**: IIPC frequently yields the highest accuracy (e.g., Gemini 2.0 Flash’s Algebra IIPC=99.53), while MACM often has the lowest (e.g., GPT-4o-mini’s Precalculus MACM=57.67). - **Model Comparison**: Gemini 2.0 Flash and Llama 4 Maverick excel across topics, with Gemini 2.0 Flash’s Algebra IIPC=99.53 as a standout. ### Interpretation The heatmaps reveal how AI models perform on math topics using different methods. High accuracy in Algebra/Prealgebra suggests these topics are more straightforward, while Geometry/Precalculus (with complex reasoning) are more challenging. IIPC’s consistent high performance implies it is an effective method for these tasks. The color gradient (purple to yellow) visually emphasizes accuracy differences, guiding model selection for math-related tasks. This data highlights which models/methods excel in specific topics, aiding in practical applications like educational AI or problem-solving tools. </details> Figure 5: Heatmaps showing accuracy by topic for each LLM, comparing PoT, CR, MACM, and IIPC agents on the MATH dataset. In our main experiments, we present a fine-grained analysis by problem difficulty and topic only for Llama 4 Maverick. This section extends this same per-difficulty and per-topic comparison to all other language models considered in this paper. Across difficulty levels (Figure 4), IIPC demonstrates strong performance on Gemini 2.0 Flash, Mistral Small 3.2 24B, Gemma 3 27B, and Llama 4 Maverick, while slightly trailing PoT on GPT-4o mini. On Gemini 2.0 Flash, IIPC maintains high accuracy from 96.77% at Level 1 to 87.38% at Level 5, whereas MACM drops from 94.98% to 77.41%, a 9.97% difference at the highest difficulty. Similar trends are observed on Mistral 3.2 24B (IIPC: 96.77→80.07; MACM: 92.47→63.79), Gemma 3 27B (IIPC: 95.34→79.40; MACM: 95.70→71.10), and Llama 4 Maverick (IIPC: 96.06→80.73; MACM: 96.06→72.43), indicating that IIPC better preserves reasoning stability under increasing problem complexity. In contrast, on GPT-4o-mini, PoT maintains an edge over IIPC. We also observe that IIPC maintains the highest accuracy on the most difficult problems on all models except GPT-4o-mini. The topic-wise analysis (Figure 5) reveals similar patterns. On Gemini 2.0 Flash, IIPC leads in algebra (99.53%), number theory (98.51%), prealgebra (97.67%), and precalculus (94.88%). On Gemma 3 27B, IIPC maintains a lead in geometry (82.38%), intermediate algebra (88.37%), prealgebra (94.88%), and precalculus (87.91%), outperforming other agents by multiple points. On Llama 4 Maverick, IIPC’s performance either matches or surpasses that of all other agents across most topics, demonstrating IIPC’s ability to fully utilize the reasoning capabilities of high-performing models. On GPT-4o mini, PoT tends to lead IIPC by significant margins. ## Appendix D IIPC Reasoning Examples Figure 6 is a program refinement generated by Gemini 2.0 Flash when solving an AIME problem. IIPC allows the LLM to reflect on its previous program, identify the incorrect assumption, and propose the fix before developing a new program that produces the correct output. Figure 7 demonstrates the fusion stage of the IIPC agent, where it combines both reasoning branches to produce the final reasoning chain. Here, Llama 4 Maverick makes a mistake in its program by reversing the terms in the formula that calculated the dot product, resulting in a negative value. However, it identifies and applies the correct formula in the token-reasoning branch. In the final reasoning chain, which was conditioned on context from both branches, IIPC allows the LLM to deliberate between both sources and identify the error in the program branch, resulting in a correct final answer. Problem: A right circular cone has a base with radius 600 and height $200\sqrt{7}$ . A fly starts at a point on the surface of the cone whose distance from the vertex of the cone is 125, and crawls along the surface of the cone to a point on the exact opposite side of the cone whose distance from the vertex is $375\sqrt{2}$ . Find the least distance that the fly could have crawled. Original Program ✗: python code ... # The angle difference is pi. d = math.sqrt(r1**2 + r2**2 - 2 * r1 * r2 * math.cos(math.pi)) python code ... Original Program Output ✗: The slant height of the cone is: 800.0 The central angle of the sector is: 4.71238898038469 The shortest distance the fly could have crawled is: 655.3300858899107 655.3300858899107 Reflection: The previous program calculates the slant height and central angle correctly. However, it incorrectly assumes that "exact opposite side of the cone" translates to an angle difference of $\pi$ in the flattened sector. The correct angle difference should be $\pi$ radians *only if* the central angle of the sector is $2\pi$ . In general, the angle difference should be $\pi*(2\pi/\theta)$ , where $\theta$ is the central angle of the sector. The program also lacks verification that the final answer is reasonable. Refined Program ✓: python code ... # Calculate the angle difference. delta_theta = math.pi * r / l print(f"The angle difference is: {delta_theta}") # Calculate the shortest distance using the law of cosines. d = math.sqrt( r1**2 + r2**2 - 2 * r1 * r2 * math.cos(delta_theta) ) python code ... Refined Program Output ✓: The slant height of the cone is: 800.0 The central angle of the sector is: 4.71238898038469 The angle difference is: 2.356194490192345 The shortest distance the fly could have crawled is: 625.0 The calculated distance is less than the sum of the distances from the vertex, which is expected. Performing alternative verification... Approximate shortest distance: 624.9134519586773 Figure 6: Example of IIPC’s program refinement mechanism using Gemini 2.0 Flash. Only significant changes in the code are displayed to control figure size. The full example text is provided in the GitHub repository. Problem: In triangle $ABC,$ $AB=3$ and $AC=5.$ Let $O$ be the circumcenter of triangle $ABC.$ Find $\overrightarrow{OA}\cdot\overrightarrow{BC}.$ Program Branch (Contains Flawed Logic ✗): import numpy as np # Define vectors AB and AC AB = np.array([3, 0]) # Assuming AB lies on the x-axis # Since we’re working with a general triangle, # let’s consider the angle between AB and AC # We’ll directly use the property that OA . BC = (ACˆ2 - ABˆ2)/2 # Calculate OA . BC using the formula derived from the # properties of the circumcenter and dot product AC_length = 5 AB_length = 3 OA_dot_BC = (AC_length**2 - AB_length**2) / 2 print("The dot product of OA and BC is: ", OA_dot_BC) # Verification assert np.isclose( OA_dot_BC, (5**2 - 3**2) / 2 ), "Incorrect calculation" Original Program Output ✗: The dot product of OA and BC is: 8.0 CoT Branch Text ✓: Step 1: To solve the problem, we need to start by understanding the given information and what is being asked. We are dealing with triangle $ABC$ , where $AB=3$ and $AC=5$ . The circumcenter of the triangle is $O$ , and we are required to find the dot product of $\overrightarrow{OA}$ and $\overrightarrow{BC}$ . Step 2: First, let’s recall that the circumcenter $O$ of a triangle is the point where the perpendicular bisectors of the sides of the triangle intersect. This means $O$ is equidistant from the vertices $A$ , $B$ , and $C$ . … Step 13: Now, we substitute $AB=3$ and $AC=5$ into the expression to find $\overrightarrow{OA}\cdot\overrightarrow{BC}$ . Step 14: $\overrightarrow{OA}\cdot\overrightarrow{BC}=\frac{3^{2}-5^{2}}{2}=\frac{9-25}{2}=\frac{-16}{2}=-8$ . The final answer is: $\boxed{-8}$ Final Reasoning Chain (Using Both Context Sources) ✓: The objective of the given problem is to find the dot product of vectors $\overrightarrow{OA}$ and $\overrightarrow{BC}$ in triangle $ABC$ , where $AB=3$ , $AC=5$ , and $O$ is the circumcenter of the triangle. Upon analyzing the context from both the code and the reasoning chain, it is evident that they both lead to the same formula for calculating $\overrightarrow{OA}\cdot\overrightarrow{BC}$ , which is $\frac{AC^{2}-AB^{2}}{2}$ . The reasoning chain provides a detailed step-by-step derivation of this formula using properties of the circumcenter and dot product. The code directly implements this formula to calculate $\overrightarrow{OA}\cdot\overrightarrow{BC}$ . However, upon closer inspection, it is noticed that the code contains a logical error in its output. The correct calculation should yield a negative result because $AC>AB$ , and the formula is $\frac{AB^{2}-AC^{2}}{2}$ . To correct this, we should negate the output of the code or directly use the correct formula. The correct calculation is $\frac{3^{2}-5^{2}}{2}=\frac{9-25}{2}=-8$ . Combining the insights from both the code and the reasoning chain, we arrive at the final answer. The code is genuinely helpful in solving the problem and, with a correction, produces an accurate output. The final answer is: $\boxed{-8}$ Figure 7: Example of IIPC’s dual branch mechanism using Llama 4 Maverick. CoT output has been shortened to control image size. The full example text is provided in the GitHub repository.