Instead of writing a chain of words, MARC represents a problem as a constraint graph and solves it by iteratively denoising that graph toward a checker-verified state — offloading arithmetic to an exact engine and reasoning about structure.
Chain-of-thought works, but three cracks motivate a different substrate. MARC keeps the reasoning and removes the cracks by moving computation into a structured, verifiable object.
Much benchmark performance reflects solutions seen in training, not reasoning. A system that can recall an answer can't be trusted to have derived it.
The written chain often doesn't match the computation that produced the answer — a post-hoc story, unreliable to study or verify.
Token models compute digits poorly and burn capacity tracking them. The mechanical part belongs in a calculator, not the model.
Four ideas do all the work — and none of them has the model write out its reasoning in words. The thinking happens inside a structured object that can be checked at every step.
Every quantity in the problem — knowns and unknowns alike — is a variable node. Every relation it must satisfy — an equation, an inequality, a definition — is a constraint node wired to the variables it touches.
There is no first step or last step. The whole graph is the problem, and a solution is simply an assignment where every constraint is satisfied at once.
The model doesn't hunt for a path to the answer. It starts from a noisy guess and denoises the whole graph — nudging every value toward consistency, again and again, until nothing is violated.
The injected noise isn't a flaw: it's what lets the process escape states that look locally fine but are globally wrong — the trap that sinks ordinary constraint solvers.
A computer-algebra engine measures exactly how violated each constraint is. Those residuals are the signal that steers every denoising step.
So the model never grinds through digit arithmetic — the thing it's worst at. It spends capacity on which constraints to attack and how to move, and leaves exact computation to the engine.
The single reward is whether a checker accepts the result. There's no answer key to copy, so the model can't fall back on recalling a memorized solution — it has to produce something that actually checks out.
We confirm it's truly deriving by testing on unseen structure and far larger problems than it trained on. Memorization can't fake that; only a real procedure generalizes.
| Chain-of-thought | Symbolic tree search | MARC | |
|---|---|---|---|
| Represents a problem as | a stream of text tokens | discrete expression / proof states | a constraint graph of quantities & relations |
| Makes progress by | appending the next token, left to right | branching and searching over discrete moves | denoising the whole graph toward consistency |
| Computation lives in | the token stream (often parroted) | the search policy | a learned relaxation + an exact calculator |
| Can it recall an answer? | Yes — a real risk | Partly | No — it must produce a checkable derivation |
| Verified by | usually just the final answer | each move valid by construction | every residual must vanish; the checker gates it |
A tiny system of equations as a constraint graph. Variable nodes hold noisy values; constraint nodes show how violated each equation is. Each denoise step nudges every value at once — guided by the calculator's residuals — until the checker accepts.
The solution here is x=2, y=1, z=3. Press Denoise step and watch the residuals fall from red to amber as the whole graph settles at once — no left-to-right token order.
Why noise? Injected noise lets the relaxation escape locally-consistent-but-wrong states — the failure mode of deterministic solvers. Try + Inject noise mid-run.
The full paper is due July 27, 2026, with the abstract and title locked a week earlier on July 20. The plan: build the verifiable core first, scope the hard math to preliminary results, and reserve the final stretch for writing.
Filter the board by person. Each card is a step-by-step plan with exact file paths. All Python code goes in a new folder marc/ at the repo root — it does not exist yet; you create it and push to github.com/saidlaboratory/MARC. See TECHNICAL_GUIDE.md §13 for the full layout.
marc/data/examples/two_equations.json contract so nobody blocks anyone. Integration happens at the end of each phase, not at the start. Davin & Quang = modeling/diffusion. Akash & Sparsh = data/eval/checker.