The problem
Algebraic multigrid solves large sparse linear systems by moving between a fine grid and a coarser one. How well it works depends heavily on one decision: which unknowns become coarse points (C) and which stay fine (F). More coarse points usually mean faster convergence but a more expensive hierarchy.
Classical methods such as Ruge–Stüben make this choice with hand-designed greedy rules. This project asks whether an agent can learn splittings that trade convergence speed against cost, using feedback from the solver instead of labeled examples.
Current stage: two loops
In the current stage, an RL agent builds a splitting one coarse point at a time and is rewarded by the convergence and cost of the resulting two-grid method. Around it, a language model acts as a research assistant for the training process:
- ProposeThe LLM reads training diagnostics and suggests how the agent should be trained next.
- CheckA compiler validates the proposal against fixed bounds and rejects anything out of scope.
- TrainThe agent is retrained under the same seeds and episode budget.
- JudgeA frozen evaluation measures convergence and cost; only non-dominated agents are kept.
The loop repeats, with the kept agents and their diagnostics fed back to step 1.
The key design choice is a clean separation of roles. The LLM can change how the agent learns, but it never sees or edits the evaluation, and it cannot declare its own proposal a success. Whether a trained agent is kept is decided by the numerics alone, on a Pareto front of convergence factor against operator complexity.
Next stage
In this stage, the language model itself will be trained. The solver becomes a verifiable-reward environment for GRPO post-training: every reward comes from actually building and running a multigrid hierarchy rather than from a proxy, it balances convergence against operator complexity, and it is scored by the same frozen evaluation the model cannot see or edit.