🤖 AI

Iteris: Agentic Research Loops for Computational Mathematics

This paper introduces Iteris, an agentic AI system designed for open problems in computational mathematics, which successfully generated numerical evidence, constructions, and proof drafts for two complex research challenges that were subsequently verified by human experts.

Original authors: Leheng Chen, Zihao Liu, Wanyi He, Bin Dong

Published 2026-06-02

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Leheng Chen, Zihao Liu, Wanyi He, Bin Dong

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a team of researchers trying to solve two very tricky, unsolved puzzles in the world of numbers and algorithms. These aren't just simple math homework problems; they are open questions that professional mathematicians have been stuck on for a while.

To tackle these, the authors built a digital research assistant called Iteris. Think of Iteris not as a single super-brain, but as a collaborative workshop run by a team of specialized AI agents, each with a specific job.

Here is how the system works, using a simple analogy:

The Workshop Team (The Agents)

Instead of one AI trying to do everything at once, Iteris breaks the work down into a loop involving three main roles:

The Explorer (The Scout): This agent wanders around the "research forest." It doesn't make final decisions. Instead, it checks different paths, reads old notes, and asks, "Hey, is this path leading to a dead end, or is there something interesting here?" It sends a quick report to the planner.
The Planner (The Project Manager): This agent looks at the big picture. It reads the Scout's report and the project's history. It decides, "Okay, for the next step, we need to run a specific computer simulation," or "Let's try to write a proof for this specific part." It creates a to-do list.
The Executors (The Specialists): These are the workers who actually do the tasks.
- The Foundation Agent: Makes sure everyone agrees on the definitions (like making sure everyone knows what a "triangle" is).
- The Experiment Agent: Runs numbers and simulations to see what happens in the real world.
- The Proof Agent: Tries to write logical arguments to prove why something is true.
- The Review Agent: Acts as a quality control inspector, checking if the work is solid or if there are holes in the logic.

The Secret Sauce: The team doesn't just talk to each other; they leave notes in a shared "digital notebook" (files). This ensures that if the team gets stuck or goes in a circle, they can look back at what they tried before and avoid repeating mistakes.

The Two Puzzles Solved

The paper describes how this team tackled two specific problems from a recent workshop:

1. The Race Between Two Runners (Conjugate Gradient vs. Randomized Coordinate Descent)

The Problem: Imagine two runners trying to reach a finish line (solving a math equation). One runner (CG) is a marathon expert who looks at the whole map at once. The other (RCD) is a sprinter who takes tiny, cheap steps but has to take many more of them. The question was: Under what conditions does the sprinter actually beat the marathoner?
The Result: Iteris ran thousands of simulations and built a "map" (a phase diagram) showing exactly when the sprinter wins and when the marathoner wins, depending on the terrain (the math properties).
The Human Touch: The AI figured out the general map, but it made a mistake in one specific area regarding how fast the runners slow down. A human mathematician spotted the error, and the AI fixed it.

2. The Badly Organized Bookshelf (QR Factorization)

The Problem: Imagine you have a bookshelf (a matrix) and you want to pick the best books (columns) to keep so the shelf stays stable. There is a standard rule (QRCP) that says, "Pick the book that looks the heaviest." The question was: Does this rule always pick a stable set of books, even if the books are arranged in a tricky way?
The Result: Iteris tried to prove the rule always works, but kept failing. Instead of giving up, the system used those failures to figure out how to build a "trick bookshelf" that breaks the rule. It constructed a specific, counter-intuitive example where the rule picks a wobbly, unstable set of books.
The Human Touch: The AI built the "trick bookshelf," but the explanation was messy and hard to read. A human mathematician had to reorganize the AI's messy notes into a clean, readable story that other humans could understand.

The Big Takeaway

The paper argues that AI is getting good enough to help with real, open research, but it's not a magic wand that solves everything automatically.

What the AI did well: It explored many different ideas, ran massive numbers of experiments, and built the rough drafts of the proofs. It found the "shape" of the solution.
What the Human did: The human acted as the editor and the safety net. They caught the AI's logical errors, fixed the messy explanations, and made sure the final result was mathematically sound.

In short, Iteris is a powerful research partner that generates ideas and drafts, but it still needs a human expert to verify, repair, and polish the final work. The paper shows that this "human-in-the-loop" approach is currently the best way to solve hard problems in computational mathematics.

Technical Summary: Iteris: Agentic Research Loops for Computational Mathematics

1. Problem Statement

The paper addresses the challenge of applying AI to open problems in computational mathematics. Unlike competition problems or single-objective optimization tasks, research in this domain requires a complex interplay of numerical experimentation, adversarial construction, and formal proof development. Current AI systems often struggle to coordinate these distinct research modes or to maintain long-horizon research trajectories where facts must be separated, checked, and reorganized.

The authors apply their proposed system, Iteris, to two specific open problems from the Simons Workshop collection [3]:

Problem 2.4: An asymptotic comparison between Conjugate Gradient (CG) and Randomized Coordinate Descent (RCD) on linear systems with power-law spectra. The goal is to determine a phase diagram for the normalized cost ratio between the two methods.
Problem 4.3: A question regarding whether QR factorization with column pivoting (QRCP) reliably selects well-conditioned submatrices from a matrix with orthonormal rows, specifically under low-coherence conditions.

2. Methodology: The Iteris System

Iteris is an agentic research system organized as an explore–plan–execute loop. It coordinates distinct research modes through a file-based memory system that serves as both long-term state storage and structured messaging between agents.

2.1 The Agentic Protocol

Each iteration of the system follows three distinct phases:

Explore: An Exploration Agent performs "light repository-level probing." It reads project files, inspects recent iterations, and drafts scratch reasoning over plausible routes. Crucially, it does not write the official plan but produces an advisory recording recommended task shapes, local-minimum checks, and risk assessments to prevent the system from over-committing to a stagnant branch.
Plan: A Plan Agent reads the global project state (problem statement, roadmap, memory, route status) and the exploration advisory. It decides the task pool for the next iteration, outputting a structured TASK_POOL.json that defines task categories, goals, inputs, and verification requirements.
Execute: Specialized Execution Agents receive assigned tasks and perform specific research actions, writing structured result files back to the project memory.

2.2 Execution Agents

The system employs four categories of execution agents, each with task-specific skills defined by Markdown-based capability specifications:

Foundation Agent: Audits sources, freezes definitions, drafts conjecture cards, and maintains claim discipline.
Experiment Agent: Runs numerical work (test harnesses, diagnostics, counterexample searches). Evidence is treated as guidance, not proof.
Proof Agent: Constructs and checks proof artifacts for stable statements, special cases, or lemmas.
Review Agent: Evaluates evidence, proof gaps, and route value, recommending whether to deepen, reframe, or retire a research branch.

2.3 Separation of Concerns

A key design feature is the separation of the Exploration Agent from the Plan Agent. While the Plan Agent maintains global coherence, the Exploration Agent runs aggressive probes to detect "local inertia" (e.g., incremental follow-up work) and suggests alternative directions before a task is officially committed. This allows the system to search beyond its current path while keeping planning globally coherent.

3. Key Contributions and Results

3.1 Result I: CG vs. RCD Phase Diagram

Iteris was applied to the comparison of CG and RCD on power-law spectra ( $A_n = U_n \text{diag}(1^{-p}, \dots, n^{-p})U_n^*$ ).

Theorem 1: The system established a fixed-parameter phase diagram for the asymptotic behavior of the ratio $\rho_n(\epsilon, p)$ (RCD epochs vs. CG steps) as $n \to \infty$ .
Key Findings:
- For $p > 1$ (summable spectrum), RCD converges in $O(1)$ epochs while CG takes $O(n)$ steps, so $\rho_n \to 0$ .
- For $p = 1$ , $\rho_n \to 0$ with a logarithmic bound.
- For $0 < p < 1$ , the behavior is governed by a limiting CG floor $F(p)$ , derived from a finite-dimensional moment problem involving the tail measure $\nu_p$ .
- If the error threshold $\epsilon < F(p)$ , CG requires growing degrees to converge, while RCD remains bounded, causing $\rho_n \to 0$ .
- If $\epsilon > F(p)$ , CG converges in $O(1)$ steps while RCD requires a positive fraction of an epoch, causing $\rho_n$ to be bounded away from zero.
Human-AI Interaction: The system identified the phase structure and the "Hankel floor" mechanism. However, an initial proof draft relied on an unjustified stronger assumption for the rate analysis in the $p < 1$ regime. Human experts detected this gap, and the argument was repaired through interaction to provide conservative, verified rate bounds.

3.2 Result II: QRCP Counterexample

Iteris addressed whether QRCP guarantees well-conditioned submatrices for matrices with orthonormal rows and bounded coherence.

Theorem 2: The system constructed a low-coherence counterexample family showing that QRCP can fail to select well-conditioned submatrices, even when row energies are uniformly controlled.
Key Findings: For any $H^* > 1$ (coherence bound) and $B > 0$ , there exists a matrix $Q$ with orthonormal rows and coherence $\mu(Q) < H^*$ such that the condition number of the selected submatrix exceeds $B k^e$ .
Mechanism: The counterexample exploits a "triangular back-substitution" pressure. The system designed a selected core block that satisfies local pivot conditions but creates a large inverse norm. Additional columns were added to restore global orthonormality without being selected by the pivoting rule.
Human-AI Interaction: Iteris identified the obstruction and generated the construction. The proof trajectory was initially circuitous; human experts reorganized the argument into a readable proof and aligned the informal theorem with a formal Lean 4 verification.

4. Significance and Claims

The paper claims that agentic AI systems can participate meaningfully in research workflows for open problems in computational mathematics, but emphasizes that human validation remains essential.

Beyond Benchmarks: Iteris demonstrates that AI can move beyond solving isolated exercises to participating in genuine research, generating long-horizon exploratory artifacts and proof drafts.
Workflow Integration: The system successfully coordinates numerical experimentation (to identify structural features like the Hankel floor or back-substitution pressure) with formal proof construction.
Role of Human Intervention: The authors explicitly state that Iteris shifts rather than removes human effort.
- In the CG case, the system found the structure, but humans repaired the rate analysis.
- In the QRCP case, the system found the counterexample, but humans reorganized the proof and verified semantic consistency.
Comparison to Direct LLMs: Direct queries to advanced models (e.g., GPT-Pro) produced plausible heuristics or high-level sketches but failed to close proofs, often blurring distinctions between expected and high-probability bounds or treating plausible steps as discharged obligations. Iteris, by contrast, decomposes heuristics into auditable proof obligations and uses review agents to block unjustified shortcuts.

The paper concludes that while AI can broaden the search space and produce draft arguments, the final mathematical judgment, verification of assumptions, detection of gaps, and exposition remain critical human responsibilities.