Reasoning without Gold Standards: A Proxy-Judge Theory of Autoformalization

arXiv:2606.09449 · cs.CL · Submitted 2026-06-08 · Read on arXiv

Listen

Transcript

Introduction to the show: ident: AI Radio. Generated commentary on the latest Artificial Intelligence papers.

Tom: Today's paper: "Reasoning without Gold Standards".

Jane: The gist: A reference-free proxy-judge framework for autoformalization replaces gold-standard matching with a vector of per-axis property checks,

Tom: First, who's behind it and why it matters.

Paper summary: Tom: So we’re looking at this paper, "Reasoning without Gold Standards: A Proxy-Judge Theory of Autoformalization." It tackles a huge problem in AI where you want a model to translate informal reasoning into something formal, but getting that perfect formalization is just too hard and expensive.

Jane: Right. The core idea here is ditching the need for one single perfect reference—that gold standard matching—and instead using a whole vector of property checks to guide the process. It claims that you can achieve autoformalization without needing a fixed, expert-validated reference for every single task <ref:2606.09449#pg1>.

Lu: Basically, they introduce this reference-free proxy-judge framework. Instead of matching against one perfect answer, you check the candidate formalization across three structural scopes: global properties of the object, things internal to its subcomponents, and how well it aligns with the original informal source and some context <ref:2606.09449#pg2>.

Meng: So instead of one pass/fail signal, you get a verdict vector—a bunch of scores on different axes—and that vector drives a reflective refinement loop where the system targets the worst-scoring part for repair <ref:2606.09449#pg2>.

Tom: That sounds like they're turning the problem into constraint-directed repair instead of just guessing and retrying, which is a big deal for how we build these systems. But what exactly is this proxy judge doing?

Jane: Well, they have eight different judges in this framework, each checking something specific about the candidate formalization <ref:2606.09449#pg8>. These checks fall into global properties, per-module properties for subcomponents, and cross-domain properties that check if everything traces back to the informal source <ref:2606.09449#pg10>.

Lu: The loop itself is defined as proposing a candidate, scoring it on this vector of axes, finding the worst violation, and then applying a repair targeted at that specific axis <ref:2606.09449#pg2>. They also have some theory about how imperfect checks shape iterative refinement, suggesting that the gap between the current formalization and the true one contracts geometrically to some kind of noise-dependent plateau <ref:2606.09449#pg9>.

Meng: Contractive drift sounds promising for stability at scale, but what does this actually look like in practice when we think about deployment?

Jane: The paper shows that under certain assumptions, the expected intrinsic gap shrinks geometrically to an O(eta) plateau where eta is some noise factor <ref:2606.09449#pg9>. This means the system doesn't just keep failing; it gets systematically closer to a solution, even when the checks aren't perfect.

Tom: I see you talking about the convergence analysis now. The paper also establishes some really interesting results about how damage happens to a correct formalization versus how harmful revisions are introduced <ref:2606.09449#pg3>.

Lu: They found that to actually damage a correct formalization, you need a false rejection that exposes it to further refinement, and then harmful changes are retained through things like unguarded edits or the system making progress in a way that overrides the judge's warnings <ref:2606.09449#pg3>.

Jane: And they decompose the final pass rate into three parts: continued refinement, generating new candidates, and those candidates succeeding at passing the checks <ref:two thousand six hundred six point zero nine four four nine#pg3. That gives a clearer picture of where the system is spending its time during this iterative process.

Paper summary: Meng: So it's not just about getting a higher pass rate on one try, but understanding how much effort goes into fixing things versus just trying something completely new <ref:two thousand six hundred six point zero nine four four nine#pg3. That’s more relevant for debugging large model pipelines.

Tom: The empirical testing shows that this framework consistently beats single-shot evaluation baselines across seven formalization backbones and four different datasets <ref:2606.09449#pg9>. On the frontier three backbones, they see average gains of nineteen percent on ProofNet and sixteen percent on e-SNLI <ref:2606.09449#pg9>.

Jane: Those numbers are pretty strong when you compare them to the ICL baseline, showing that this per-axis decomposition really helps capture the gains over a single overall score on those benchmarks <ref:2606.09449#pg9>. It seems like the granularity gain is quite significant on those two tests.

Lu: The framework uses eight proxies to test these predictions, and they instantiated it across ProofNet and miniF2F in Lean four as well as e-SNLI and ProntoQA in Isabelle/HOL <ref:2606.09449#pg9>. They also tested the removal of a single proxy, which showed that no prediction written before the runs was contradicted, and all traced breaks followed the identified failure routes <ref:two thousand six hundred six point zero nine four four nine#pg3.

Meng: That’s interesting—the fact that removing one judge doesn't suddenly break everything suggests the framework is robust enough to handle some noise in its judges <ref:two thousand six hundred six point zero nine four four nine#pg3. But what about the practical limits of this whole setup?

Jane: The authors are pretty clear about what it doesn't do; they state that their notion of correctness is audit-sufficient rather than fully semantic <ref:2606.09449#pg9>. They also noted that the empirical advantage from this per-axis decomposition is currently dataset-conditional, meaning you might need to test it on benchmarks with broader topic coverage to see the full benefit <ref:2606.09449#pg9>.

Tom: So, if we put it all together, this paper introduces a way to evaluate autoformalization by turning it into constraint-directed optimization over these property checks <ref:2606.09449#pg9>. It seems the main contribution is showing how to use these proxies effectively without relying on expensive gold standards.

Jane: The title, "Reasoning without Gold Standards: A Proxy-Judge Theory of Autoformalization," really captures that shift from matching against a perfect answer to using a structured vector of checks <ref:two thousand six hundred six point zero nine four four nine#pg1. It suggests that the signal for correctness already exists inside the formal system itself once you make the reasoning explicit enough.

Lu: For future work, they suggest integrating this per-axis verdict vector into reinforcement learning fine-tuning of either the proposer or the judge, which would be a natural next step in making this loop even more adaptive <ref:2606.09449#pg9>.

Meng: From an engineering standpoint, if we can manage to make these checks reliable and scalable, this framework could drastically reduce the time spent on generating correct formalizations where we currently rely on slow, expensive manual validation <ref:two thousand six hundred six point zero nine four four nine#pg1.

Tom: Exactly. It moves us from hoping for a perfect single output to systematically refining an object based on localized, measurable failures across multiple dimensions <ref:two thousand six hundred six point zero nine four four nine#pg2. That's the direction this research is pushing the field in right now.

Conclusion: Tom: So we’re wrapping up this look at "Reasoning without Gold Standards: A Proxy-Judge Theory of Autoformalization." Essentially, this paper is about figuring out how to get AI models to translate messy, human reasoning into formal proofs without needing a perfect reference answer for every single proof.

Jane: Right. It moves away from that idea of matching against one gold standard and instead uses a bunch of checks—a vector of them—to guide the refinement process. It’s using proxies to see how good a candidate formalization is across different properties, not just whether it matches the final version perfectly.

Lu: The core idea is this decomposition: you break evaluation into global properties, things inside sub-components, and cross-domain checks against your original informal source. That vector of scores drives a loop where the system fixes the worst violation first.

Meng: From a deployment standpoint, that sounds much more manageable than trying to get one monolithic answer right from the start. It’s about targeted repair rather than just hoping for a full pass.

Tom: Exactly. And they show that this refinement process isn't just random guessing; under certain conditions, the gap between your current formalization and the correct one shrinks geometrically, eventually leveling off at some noise-dependent plateau.

Jane: That’s a big thing because it suggests that even with imperfect checks—which is how we usually work—the system gets systematically closer to the right answer over many iterations. It’s a theory about how noisy checks shape learning itself.

Lu: The authors also lay out some mechanics for what happens during refinement, like how damage to a correct formalization requires specific types of false rejections that let the system expose flaws and then fix them.

Tom: And they give us this decomposition of the final pass rate into three things: continued refinement, generating entirely new candidates, and those new candidates finally succeeding at passing all checks. It gives you a way to measure where your time is actually going in the loop.

Jane: So what does this mean for us? It suggests that if we can't get perfect matches from a reference, we can still build robust formalization systems by focusing on these measurable property checks and letting the system self-correct iteratively.

Meng: If this works reliably across different backbones, it could mean less time spent on manual validation and more time actually deploying working AI reasoning tools.

Lu: The paper’s limitation is that their correctness notion is audit-sufficient rather than fully semantic, meaning it checks for a lot of things but might not be checking the deep logical meaning in every single case.

Tom: Right, so it’s a powerful tool for improving refinement loops even with noisy feedback, but we still need to figure out how to make those individual property checks themselves really reliable and scalable across different kinds of reasoning tasks.

Idiap Research Institute · École Polytechnique Fédérale de Lausanne · Department of Computer Science, University of Manchester, United Kingdom · CRUK National Biomarker Centre, University of Manchester, United Kingdom

cs.CL

Submitted: 2026-06-08

Updated: 2026-10-14

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 89/100

The gist: The gist: A reference-free proxy-judge framework for autoformalization replaces gold-standard matching with a vector of per-axis property checks, driving a reflective refinement loop that contracts

Key concepts

Autoformalization (AF): AF is the process of automatically generating formal proofs from informal natural language arguments. The challenge is that there are many valid ways to formalize one argument, and checking correctness without a perfect reference is difficult.
Proxy-Judge Framework: This framework replaces exact matching with a set of eight specialized judges (proxies). These judges evaluate different aspects of the generated proof—global properties, module internals, and cross-domain alignment—providing a detailed verdict vector instead of just one final score.
Refinement Loop: This is an iterative process where the system measures violations from the proxy judges. Based on which violation is strongest, the system directs a specific repair to that subcomponent. This turns simple retries into constraint-directed repairs, systematically closing the gap between the current proof and correctness.
Audit-Unit Axes: Evaluation is broken down into three structural scopes: global properties of the entire object, properties internal to individual modules, and cross-domain checks that ensure consistency with the original informal source. These axes allow for granular error localization during refinement.

Terminology

Benchmark — 33× in this paper · explained in 2 episodes
Calibration — 9× in this paper · explained in 7 episodes
Ablation — 5× in this paper · explained in 1 episode
Trace — 5× in this paper · explained in 2 episodes
Aggregation — 4× in this paper · explained in 1 episode
Grounding — 4× in this paper · explained in 3 episodes
Verifier — 4× in this paper · explained in 2 episodes
Abstention — 3× in this paper · explained in 1 episode
Fine-Tuning — 3× in this paper · explained in 5 episodes
Iterative Refinement — 3× in this paper · explained in 3 episodes
Reinforcement Learning — 3× in this paper · explained in 4 episodes
Semantic Preservation — 3× in this paper · explained in 2 episodes
Consistency — 2× in this paper · explained in 3 episodes
Core — 2× in this paper · explained in 2 episodes
Fidelity — 2× in this paper · explained in 2 episodes
LLM judge — 2× in this paper · explained in 2 episodes
Self-consistency — 2× in this paper · explained in 2 episodes
Accuracy — 1× in this paper · explained in 1 episode
Coherence — 1× in this paper · explained in 2 episodes
In International Conference on Learning Representations — 1× in this paper
LLM-as-a-Judge — 1× in this paper · explained in 3 episodes
Provenance — 1× in this paper · explained in 4 episodes
Verifiability — 1× in this paper · explained in 3 episodes
Verification — 1× in this paper · explained in 2 episodes

Summary

The gist: A reference-free proxy-judge framework for autoformalization replaces gold-standard matching with a vector of per-axis property checks, driving a reflective refinement loop that contracts the intrinsic gap geometrically to a noise-dependent plateau.

Introduction and Motivation

Complex reasoning tasks increasingly require systems to produce outputs whose correctness cannot be judged by exact match against a single reference, and Autoformalization (AF) is a representative example of this challenge <ref:2606.09449#pg2> Expert-validated formalizations do not scale beyond toy cases and a single informal argument can admit many valid formal renderings <ref:2606.09449#pg3>. The difficulty is compounded by non-uniqueness, as a single informal argument can admit many valid renderings, differing in definitions, encodings, lemma decompositions, proof strategies, or library alignments <ref:2606.09449#pg4>. Evaluation must therefore move from reference reproduction to structured evidence of correctness <ref:2606.09449#pg4>.

Proposed Framework

The framework decomposes evaluation into audit-unit axes organized by three structural scopes: global properties of the elicited object, per-module properties internal to its sub-components, and cross-domain properties that re-align it to the informal source and the per-instance fact context <ref:2606.09449#pg6>. The resulting verdict vector drives a reflective refinement loop in which each detected violation routes the controller toward a localized repair, turning refinement into constraint-directed repair rather than undifferentiated retry <ref:2606.09449#pg6>.

Judges and Local Properties

A finite family of m judges Ξ = 8, each a computable functional ξk: E → [0, 1], evaluates properties of Pb and its bindings <ref:2606.09449#pg8>. The three structural scopes are:

Global scope (judge consumes the whole elicited object Pb; kernel-decided): includes ξglb(Pb) which checks if the prover completes the full elaboration and inference pass without crash, timeout, or non-termination <ref:2606.09449#pg9>.
Per-module scope (judge consumes a single module M ∈ Pb; kernel-decided): includes ξsyn(M) to check if every statement inside module M is accepted by the parser and rule schemas <ref:2606.09449#pg9>.
Cross-domain scope (judge additionally consults the informal source nl and per-instance context Γ; externally judged): includes ξgnd(M, nl, Γ) which checks if every predicate, constant, or symbol used inside M traces back to an entity introduced by nl or by Γ <ref:2606.09449#pg10>.

Refinement Loop and Convergence Analysis

The loop proceeds as follows: 1. Propose Pbi via Πθi(nl, Γ). 2. Measure ξ(Pbi) = (ξ1(Pbi),..., ξm(Pbi)). 3. Localize the target subcomponent ti responsible for the strongest violation. 4. Repair Update θi+1 ← Refine(θi, ti, ξ(Pbi)) <ref:2606.09449#pg6>. Under Assumption 2 (Bounded regress with contractive drift), the expected intrinsic gap contracts geometrically to an O(η) plateau <ref:2606.09449#pg9>. Theorem 1 shows that the expected intrinsic gap satisfies E[gi+1] ≤ (1 − λ) E[gi] + b η, leading to a limit where the plateau approaches 1 when η → 0 <ref:2606.09449#pg9>.

Empirical Results

The refinement framework consistently outperforms the single-shot ICL baseline across seven formalization backbones and four datasets <ref:2606.09449#pg9>. On the frontier three backbones, average gains reach 19% on ProofNet and 16% on e-SNLI <ref:2606.09449#pg9>. The granularity gain captures a sizeable share of the loop’s overall gain over the ICL baseline on these two benchmarks <ref:2606.09449#pg9>.

Judge Capacity and Feedback Format

The per-axis verdict vector outperforms a single end-to-end score wherever the baseline Pass Rate is below saturation <ref:2606.09449#pg9>. The proxy trajectory follows the same periteration shape as the external oracle, even though they measure quality on different scales <ref:2606.09449#pg9>. Cross-seed oracle voting reduces single-sample LLM-judge noise in the calibration setup, keeping the cohort pass rate within ±1.2% of any seed <ref:2606.09449#pg9>.

Limitations

The notion of correctness is audit-sufficient rather than fully semantic <ref:2606.09449#pg9>. The empirical advantage of per-axis decomposition is currently dataset-conditional, requiring evaluation on benchmarks with broader topic coverage <ref:2606.09449#pg9>. The framework as presented is purely an inference-time refinement procedure, and integrating the per-axis verdict vector into reinforcement learning fine-tuning of either the proposer or the judge is a natural next step <ref:2606.09449#pg9>.

Conclusion

We recast autoformalization evaluation as constraint-directed optimization over a per-axis vector of verifiable property checks <ref:2606.09449#pg9>. Across seven backbones and four datasets the resulting refinement loop consistently improves Pass Rate, and ablations identify the per-axis proxy as the source of this advantage <ref:2606.09449#pg9>.

How it works

Judge Capacity and Feedback Format

The per-axis verdict vector outperforms a single end-to-end score wherever the baseline Pass Rate is below saturation <ref:2606.

Improvements for AI systems

The system can perform constraint-directed repair rather than undifferentiated retry by utilizing a vector of per-axis property checks to drive a reflective refinement loop, ensuring each iteration changes only what is judged wrong.
The AI can achieve geometric convergence to a noise-dependent plateau using the drift-Lyapunov argument, where the expected intrinsic gap contracts geometrically to an O(η) plateau, leading to high confidence in formalization correctness even with imperfect judges.
The system gains empirical accuracy by replacing a single end-toend judge with a per-axis proxy and leveraging structured per axis feedback, which captures a significant portion of the overall gain over baseline, especially on benchmarks where the baseline has room to improve.
The model can be calibrated using an approximate stand-in for the gold label (the oracle) by comparing its per-iteration pass rate against a proxy score, ensuring that audit-sufficient acceptance and semantic correctness are empirically correlated even though they are not formally identified.
The system can dynamically adjust its refinement strategy based on the violation type by selecting a target subcomponent responsible for the strongest violation, turning refinement into a targeted process rather than generic retries.