acceptodds
Under review as a conference paper at ICLR 2027

ProofLoom: Proof-Obligation-Driven Theory Construction for Autoformalizing Research-Level Stochastic Optimization

Abstract

Formalizing research-level stochastic optimization in Lean requires a Lean model of the algorithm and domain theory that connects foundational libraries to its convergence proof. Published proofs often compress these connections, and whether a Lean model supports the complete proof may become clear only as the proof proceeds. Revising the model to restore provability, however, can change the mathematical claim. We introduce ProofLoom, an LLM-agent autoformalization system for Proof-Obligation-Driven Theory Construction. Starting from a Lean algorithm model and its main theorem statement, ProofLoom uses open proof obligations to select definitions, interfaces, and lemmas to reuse or construct. Signature contracts record the published evidence and derived obligations for each revision of the Lean model, and an independent Judge rejects revisions that add unsupported assumptions or weaken the theorem. Planner expands the published argument into intermediate claims, and Audit checks whether the Lean proof follows that argument. Certified developments contribute verified Lean code and natural-language construction records to SOptLib for reuse across algorithms. On fifteen textbook and research-paper tasks, ProofLoom obtains mean human ratings of 6.3/7 and 6.4/7, compared with 4.9/7 and 5.0/7 for the strongest of six baselines. Across 33 developments, it produces 490,693 lines of algorithm-local Lean code with no sorry. The formalizations also expose 28 incorrect formulas, proof gaps, and algorithm–analysis mismatches in published sources across 22 developments, each with checked evidence. Anonymous code and supplementary materials are available at https://anonymous.4open.science/r/ProofLoom-E71F/.

Primary area:
neurosymbolic & hybrid AI systems (physics-informed, logic & formal reasoning, etc.)
Keywords:
stochastic optimization, formalization, Lean, proof obligations, machine-checked proofs, formal methods

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_e5BrOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

This paper presents ProofLoom, an LLM-agent framework for autoformalizing research-level stochastic optimization algorithms and their convergence proofs in Lean. The central idea is proof-obligation-driven theory construction, where proof obligations arising from a target convergence theorem guide the incremental construction of supporting mathematical definitions and lemmas.

ProofLoom combines several mechanisms: (1) a Model–Construct–Learn workflow for constructing formalizations; (2) signature contracts and an independent Judge for reviewing changes to mathematical definitions and theorem statements; (3) a Planner–Audit mechanism for decomposing proofs, tracing dependencies and diagnosing proof failures; and (4) SOptLib, a reusable library of verified stochastic optimization results and natural-language construction records.

The paper evaluates ProofLoom against six baselines on 15 stochastic optimization tasks (ten textbook and five research-paper algorithms). It reports higher human and LLM-based evaluation scores than the baselines. The paper further reports 33 formalizations comprising approximately 490,000 lines of algorithm-local Lean code, together with 28 discrepancies identified in published mathematical sources. Ablation studies address the effects of removing Judge, Planner–Audit and SOptLib.

Critical strengths
  • Interesting research problem
  • The paper recognises that a Lean proof can be formally valid while proving a statement that differs from the original mathematical claim, and proposes various methods to address this issue
  • Solid work: substantial implementation and extensive experimentation
Critical weaknesses
  • Low novelty. Many components of ProofLoom, e.g., proof decomposition, iterative proof repair, agent-based review, dependency analysis and reusable lemma libraries, have been proposed and widely used in previous work. It is unclear what is technically new in the current approach.

    The paper seems to emphasize proof-obligation-driven construction as the main conceptual contribution, but it is unclear what the essential difference is between this approach and the existing top-down, dependency-guided or goal-directed proof construction. Similarly, signature contracts and Planner–Audit appear largely to be structured LLM-agent workflows with source-grounded prompting and validation.

  • Subjective evaluation. The evaluation lacks a direct success metrics. The primary comparison uses a seven-point human evaluation rubric and LLM-based evaluation scores. The human evaluation involves two internal Lean experts, with an LLM assessment used to determine when a second expert adjudicates disagreements. The independent external validation and inter-rater agreement statistics are not reported in the main results.

  • Fairness of comparison and experiments. ProofLoom benefits significantly from SOptLib, which contains verified stochastic optimization infrastructure accumulated during earlier developments, but the baselines do not appear to have the same access. Consequently, the main results compare complete system configurations with potentially different amounts of domain-specific knowledge and reusable code.

    Moreover, the ablations of Judge and Planner-Audit are limited to some selected cases (rather than complete formalization tasks). The improvement in successful cases is relatively modest: 33/43 for the full system versus 29/43 for either ablation.

  • High computational and engineering cost. The system is allocated up to 48 hours per task, and the token counts are exceptionally large. For example, the NSMD development consumes approximately 365 million total tokens with SOptLib and 927 million without it, including cached input tokens.

    Such resource consumption raises questions about scalability, affordability and practical applicability. The paper does not provide a comparison of wall-clock time, API cost, number of LLM calls or proof-completion efficiency across the competing systems. Moreover, the amount of generated Lean code is extremely large, and code volume alone should not be regarded as an indicator of formalization quality.

Questions for authors

Q1. What is the precise technical distinction between ProofLoom and the existing systems? Which specific components do the authors consider fundamentally new, beyond their integration into a domain-specific workflow?

Q2. In the main experiments, ProofLoom has access to SOptLib, whereas the baseline systems do not appear to have the same access. Can the authors clarify how this difference affects the comparison? In particular, can they provide a comparison where the baselines have access to the same mathematical infrastructure, or ProofLoom is evaluated without SOptLib across all 15 tasks?

Q3. The Judge and Planner-Audit ablations focus on 43 selected obstructions and evaluate repair directions rather than completed formalizations. Can the authors provide end-to-end ablation results showing the impact of these components on proof completion, source faithfulness and computational cost? How were the 43 cases selected, and how representative are they of the complete benchmark?

Q4. Computational efficiency. What are the computational costs of ProofLoom and the baselines in terms of wall-clock time, LLM calls, input/output tokens and API cost? How much of ProofLoom's computational budget is consumed by planning, auditing, semantic review and proof generation, respectively?

Update. I believe the authors have addressed most of my concerns. I hence raise the score.

5 comments
AuthorsOpenReview ↗

Response to Reviewer e5Br (1/4)

Thank you for the detailed review and for recognizing the problem, the distinction between a valid Lean proof and a faithful formalization, and the scale of the work. We appreciate your questions about the methodological novelty and its experimental support. We address each point below; the shared tables are in our general response. On presentation, we rewrote the contribution paragraph without changing the method, carefully revised Figures 1 and 2 to show more clearly how the formal model and the proof co-evolve, and added the SAM model-revision example in Appendix D.2.2 (see the general response).

e5Br–Q1 (review: W1, Q1). Many components, such as decomposition, repair, agent review, dependency analysis and lemma libraries, already exist. What is technically new?

Our methodological contribution is proof-obligation-driven theory construction: open proof obligations determine where and when the formal model is revised, while signature contracts and Judge review govern those revisions against the source. This allows the formal model and its supporting theory to evolve with the proof.

Setting: the model itself is hard. In many autoformalization targets, such as competition or algebraic statements, the objects are already available in Mathlib and the statement pins them down; the difficulty lies mainly in organizing dependencies in the proof. In stochastic optimization the statement leaves the model underdetermined. A convergence theorem implicitly fixes a probability space, the filtration the iterates are adapted to, the point at which each oracle call is made, which quantities are conditionally centered or independent of which others, and the measurability of every update, including set-valued ones such as proximal steps. Published proofs leave most of this implicit, and an LLM reading the text has to reconstruct it exactly. Our artifacts show how much rests on these choices: SBMD's noise cancellation needs a measurability property of the proximal update that the book never proves, and NSAGD's bounds need conditional centering at adaptive query points (Table R3). Mathlib provides measure-theoretic probability, but not the layer these proofs work in (oracle models, adapted filtrations, martingale-difference and variance bounds, Bregman and proximal machinery, tail arguments), so most of the model is built rather than looked up, about 15,000 lines per task. Because the text underdetermines the model, whether a given model supports a proof step often becomes clear only when the proof reaches that step, so the model must be revised during proving.

The difficulty is two-sided. If the model is held fixed, an obligation that needs a missing interface property cannot be met, and a long development stalls. If the model is revised freely, a single weakened definition, or a premise that assumes what the source proves, propagates to every lemma built on it; the proof still compiles and the target statement may look unchanged (Kim et al., 2026), so a check at the end may not see it. Prior long-horizon systems settle the model's meaning mainly before proving or check it mainly at the end. LeanMarathon (Zhang et al., 2026) reviews targets adversarially before proving and assumes that the related Lean library is "sufficient and complete"; Trellis (Pegden, 2026) has a human ratify the target closure; Beyond the Library (Soltani Moakhar et al., 2026) extends and validates new definitions before formalizing the main theorems; Archon (Ju et al., 2026) revises its plan freely and checks the final statement with a comparator.

Our contribution: proof-obligation-driven co-evolution. Open proof obligations decide where and when the model is revised, and each revision is checked against the source when it is made.

  • Where and when. Ordinary proof work cannot change the model. An obligation that stays open under this lock is recorded as a blocker, with its source context and the repairs already tried, and model revision starts from this evidence, at the declaration the obligation points to.
  • What may change. Every revision of a source-facing declaration carries a signature contract with its source evidence, and the Judge checks it at that point: a new premise must be an assumption the source states, and a property the source proves remains an obligation. A weakening is stopped where it would enter, before anything is built on it.

Our mechanism turns the challenge of faithfully modeling an entire algorithm into a sequence of reconstruction tasks, each governed by a signature contract. Each contract specifies the source correspondence to preserve and the proof obligations to discharge. Starting from the target proof, these obligations drive the construction of the required definitions, interfaces, and lemmas, progressively developing the theory from the top down.

AuthorsOpenReview ↗

Response to Reviewer e5Br (2/4)

e5Br–Q2 (review: W1). How does proof-obligation-driven construction differ from existing top-down, dependency-guided or goal-directed proof construction? Are signature contracts and Planner–Audit more than structured agent workflows?

Goal-directed and dependency-guided systems decompose a goal inside a model whose meaning is fixed. ProofLoom also decomposes goals, but treats the model itself as something the proof may require to change, under the control described in Q1. This control is realized as an agent control flow, and its engineering implementation is standard; what matters is which decisions it controls and on what evidence. Each rule has a part enforced by code, not by prompting:

  • Protected interface. Code restores the protected signatures after every round of proof work.
  • Signature contracts. Contracts and open obligations persist in an append-only record. The audit fails if a contract is missing, if its evidence is a placeholder, or if a declaration has changed since its contract was recorded. The Judge decides premises against a source index in which stated assumptions and proved lemmas are separate entries.
  • Planner–Audit. Code traces each open goal through the Lean dependency graph to the source step it blocks. Audit compares the Lean route with the source proof, and a route that re-derives a result the source cites must first attempt the source route. This enables self-correction in a long-horizon agent.

The ablations test the two sides of the difficulty. Without Planner–Audit, which locates where the model must change, more developments stall: partial repairs rise from 9 to 13 of 43 cases, 4 of 11 end-to-end artifacts keep sorry, and ratings fall on 7 of 11 tasks. Without the Judge, which controls what may change, more revisions are wrong: incorrect repairs rise from 1 to 6, and ratings fall on 8 of 11 tasks (Tables R4, R6).

Example (SBMD). The noise-cancellation step, Eq. (4.6.21), needs the block proximal update to be measurable with respect to past samples, which the book does not prove. Archon's scored artifact takes a measurable proximal selector as a hypothesis; since the book never states this as an assumption, the Judge would not accept it as a premise. ProofLoom's scored artifact instead proves measurability of the canonical selector, derives the cancellation from it, and completes Theorem 4.12 (anonymized supplement, StochasticBlockMirrorDescent.lean, lines 1692 and 3764). The measurability proof uses an SOptLib lemma, but the outcome does not depend on the library: SBMD scores 7/7 both with and without it (Table R5).

Example of a model revision (SAM; Appendices D.2.2 and D.4). SAM's PAC-Bayes proof needs a Gaussian KL identity. The available formula uses Euclidean coordinates, while the development represents the probability laws on a finite-dimensional inner-product space. Transporting the formula requires a measurable coordinate map, but the original bridge allowed an arbitrary measurable structure. Planner identified this mismatch, and Refactor made the source's Euclidean Borel structure explicit on the bridge and its consumers. Judge accepted this source-supported representation change; the KL identity remained a proof obligation. ProofLoom then constructed the measurable coordinate equivalence, proved KL transport, and used the resulting identity in the PAC-Bayes proof. The revision makes the source's parameter space precise while preserving the Gaussian laws and the identity to be proved.

AuthorsOpenReview ↗

Response to Reviewer e5Br (3/4)

e5Br–Q3 (review: W2). The evaluation relies on a human rubric and LLM scores, with internal experts and no reported agreement statistics. Is there a direct success metric?

Yes. "The proof compiles" is not sufficient here, because a Lean build also succeeds when the proved statement has drifted from the source, which is the failure we study. We set out the criteria for the human 1–7 ratings in the paper and also report a target-level outcome (Table R3-T): of 28 selected targets, 26 are proved (7 exactly as stated, 6 with an evidence-backed correction, 8 within a stated scope, 5 with both), and SAPD's Theorem 4.8(a)–(b) are open. A correction attributes a discrepancy to the source, with evidence in the discrepancy catalogue; a scope restriction records a narrower formal setting, such as a finite-dimensional realization, and makes no claim that the source is wrong. This classification does not rely on any rating and can be checked against the anonymized Lean code.

On SAPD, Archon and Trellis leave key supporting proofs incomplete. Archon leaves the measurable-selector construction in auxiliary_project_singleton_graph_selector_fallback as sorry (supplement: benchmark/tasks/SAPD/candidates/C2/Algorithms/Benchmark/StochasticAcceleratedPrimalDual/Auxiliary.lean, lines 629–639). Trellis leaves the passage from pointwise bounds to the supremum gap in SAPDGapSupremumPassage as sorry (benchmark/tasks/SAPD/candidates/C5/Tablet/SAPDGapSupremumPassage.lean, lines 5–14). Within the 48-hour scoring budget, ProofLoom completed the algorithm updates, proximal subproblems and several intermediate results. With continued development, the endpoint version proves corresponding expected-gap and high-probability bounds under explicit conditions, including a one-step tail-bound condition for the high-probability result. This demonstrates ProofLoom’s ability to advance long-horizon formalization. The endpoint version is included in the supplementary materials; the paper and Table R3-T continue to count the 48-hour scored artifact, so SAPD’s two source targets remain open in those statistics.

On agreement: a Lean expert and Codex scored the 105 main-comparison artifacts independently; they agreed on 89 (84.8%), every disagreement was one point apart, Cohen's κ is 0.80, and a second Lean expert's adjudication changed 10 initial human scores. The updated supplementary materials contain the adjudication details and all rating records. Both experts are internal to the project; we are arranging independent ratings by external Lean experts and will add them to the revised version.

e5Br–Q4 (review: W3, Q2). ProofLoom has SOptLib while the baselines do not. Can you compare with baselines given the same infrastructure, or evaluate ProofLoom without SOptLib?

In the main comparison the baselines ran without SOptLib. SOptLib is not external support: ProofLoom builds it from its own certified developments, so we regard it as part of the method, and the question is whether the advantage comes only from it. We tested this both ways.

Baselines with the library (Table R1, new): on five randomly drawn benchmark tasks, ProofLoom and Archon each ran with and without SOptLib, with GPT-5.6 Sol for all four arms and a library that contains none of these tasks' own results. The library changes each system's mean rating by 0.2 (Archon 4.6 → 4.8, ProofLoom 6.0 → 5.8), and ProofLoom without the library is at least as high as Archon with it on every task (6.0 vs. 4.8; G-Eval 95.8 vs. 71.3). Using a library well requires deciding which results an open goal needs and adapting them, which is what obligation-driven construction does: with the library, ProofLoom's output tokens fall by 12%, while Archon's rise by 42%.

ProofLoom without the library (Table R5): across six pairs, including the additional ADMM and RSGD tasks, ratings change by at most one point, while token use rises in every pair, to as much as 8.3 times the original total on RSGD. These two controls cover five and six tasks, respectively; we will extend them to all benchmark algorithms in the final version.

Reviewer_FproOpenReview ↗
Rating
3
Confidence
3
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

ProofLoom addresses research-level auto-formalization in Lean, where completing a proof often requires building missing mathematical infrastructure and revising the algorithm model. Its main contribution is a workflow that lets proof obligations guide this construction while using signature contracts and semantic review to limit changes to the intended claim.

Critical strengths
  1. The problem is important and well motivated. The distinction between proving a Lean statement and faithfully formalizing the source result is especially relevant for stochastic optimization.
  2. The system design addresses this distinction concretely. Recording model changes, separating assumptions from derived obligations, and auditing actual proof dependencies are useful safeguards.
  3. The reported results are encouraging across both textbook and research-paper tasks. The mechanism ablations also provide evidence that Judge and Planner–Audit serve different purposes.
  4. The mathematical case studies are a strong part of the paper. The SAM scale mismatch, for example, illustrates how formalization can expose a substantive proof gap. The reusable infrastructure in SOptLib adds value beyond individual examples.
Critical weaknesses

My main reservations concern source-faithfulness assessment and attribution of the empirical gains.

  1. Table 2 evaluates the full system with accumulated SOptLib support against baselines without SOptLib under a 48-hour limit (Appendix A.2). While Appendix E.6 isolates SOptLib on four tasks, expanding this separation or testing a strong baseline with SOptLib would better clarify the gains from the orchestration itself.

  2. Under the human rubric (Appendix A.3, Table 5), formalizations that modify premises to repair flawed source claims or retain local scope restrictions (Level 6–7; Appendix C.4, Table 19) are aggregated together with strictly unmodified formalizations into a single mean score in Table 2. A clearer breakdown of how these two outcome categories contribute to the final score would improve interpretability.

Questions for authors
  • Did the baselines have practical access to the same SOptLib code and construction records? The library ablation in Appendix E.6 is useful, but a strong baseline with the same support would better separate the workflow contribution from reuse.

  • Could you summarize how many benchmark results prove the original claim under its original assumptions, prove a corrected claim, or remain partial, and how this classification was independently checked? This would make the source-faithfulness results easier to interpret.

4 comments
AuthorsOpenReview ↗

Response to Reviewer Fpro (1/2)

Thank you for the encouraging assessment and the suggestions on matched library access and source-target coverage. These helped us strengthen the controlled comparisons and clarify what each formalization establishes. We address each point below; the shared tables are in our general response.

Fpro–Q1 (review: W1, Q1). Did the baselines have access to the same SOptLib code and construction records, and how would a strong baseline perform with the same support?

In the main comparison they did not: the baselines ran in their native configurations without SOptLib, so Table 2 compares complete systems. SOptLib is not external support: ProofLoom builds it from its own certified developments, and we regard this accumulation as part of the method. To separate the workflow from the library, we ran the matched comparison you suggested (Table R1, new). On five randomly drawn benchmark tasks, ProofLoom and Archon each ran with and without SOptLib, with GPT-5.6 Sol for all four arms and a library that contains none of these tasks' own results.

  • The library changes each system's mean rating by 0.2 (Archon 4.6 → 4.8, ProofLoom 6.0 → 5.8).
  • ProofLoom without the library is at least as high as Archon with it on every task (equal on three, higher on two; 6.0 vs. 4.8), and the automatic scores agree (G-Eval 95.8 vs. 71.3).
  • On AMSGrad, PAGE and SAPD all four arms receive the same rating; the gap comes from SCCSP and SZO.

The library does little for Archon because using it well requires what ProofLoom's obligation-driven construction does: working out which results an open goal depends on, when to consult the library, and how to adapt what it finds. With the library, ProofLoom's output tokens fall by 12%, while Archon's rise by 42%.

We also extended the separation you mention (Table R5). On the four original tasks in Appendix E.6, ProofLoom without SOptLib keeps every rating (mean 6.75) while token use rises by 7.7%–154%; Archon averages 5.00 on the same tasks. The two additional pairs on ADMM and RSGD show a similar pattern: ADMM scores 6/7 in both arms, both certified, and the run without the library takes about 60% more time; on RSGD the run without the library scores 6 instead of 7, uses 8.3 times as many tokens (563.6M vs. 67.9M), and uses the full 48-hour budget.

In both controls, the library changes a rating by at most one point, for either system. SOptLib lowers the cost of formalization; the gap to the baselines does not depend on it. Its value is in reuse: each Lean declaration is stored with a natural-language construction record, so a later task recovers both a verified result and the proof obligation that motivated it. The revised PDF includes these controls.

AuthorsOpenReview ↗

Response to Reviewer Fpro (2/2)

Fpro–Q2 (review: W2, Q2). How many benchmark results prove the original claim under its original assumptions, prove a corrected claim, or remain partial, and how was this classification checked?

Table R3-T classifies each of the 28 selected targets; Table R3 gives the per-task scope. A target with several joint guarantees counts as proved only if all of them are proved.

  • Original claim, original assumptions: 7 targets (equivalent representations and implicit well-definedness conditions count as faithful).
  • Corrected claim: 6 targets. The source claim fails as printed, or its proof does not go through, with evidence in the discrepancy catalogue (Appendix C).
  • Within a stated scope: 8 targets, where the formal result holds in a narrower setting than the source states, for example a finite-dimensional realization or a nondegenerate case. This is a modelling choice and makes no claim that the source is wrong. 5 more targets have both a correction and a scope restriction.
  • Open: SAPD's Theorem 4.8(a)–(b), reported as open within the budget.

Per artifact, these categories map onto the ratings as follows. Of the six 7/7 artifacts, three prove all targets as stated (SBMD, SCCSP, RPDG) and three prove evidence-backed corrections (NSAGD, AMSGrad, STORM). Each of the eight 6/7 artifacts has a stated scope restriction or premise, and the single 5/7 artifact (SAPD) leaves its main targets open. This follows the rubric fixed before scoring (Table 8, Appendix A.4): for a corrected source result, level 7 requires the original claim, its defect, the corrected claim, their relationship and a complete proof of the corrected conclusion, while a scope restriction or a remaining hidden source assumption caps the rating at 6.

On SAPD, Archon and Trellis leave key supporting proofs incomplete. Archon leaves the measurable-selector construction in auxiliary_project_singleton_graph_selector_fallback as sorry (supplement: benchmark/tasks/SAPD/candidates/C2/Algorithms/Benchmark/StochasticAcceleratedPrimalDual/Auxiliary.lean, lines 629–639). Trellis leaves the passage from pointwise bounds to the supremum gap in SAPDGapSupremumPassage as sorry (benchmark/tasks/SAPD/candidates/C5/Tablet/SAPDGapSupremumPassage.lean, lines 5–14). Within the 48-hour scoring budget, ProofLoom completed the algorithm updates, proximal subproblems and several intermediate results. With continued development, the endpoint version proves corresponding expected-gap and high-probability bounds under explicit conditions, including a one-step tail-bound condition for the high-probability result. This demonstrates ProofLoom’s ability to advance long-horizon formalization. The endpoint version is included in the supplementary materials; the paper and Table R3-T continue to count the 48-hour scored artifact, so SAPD’s two source targets remain open in those statistics.

On checking: the ratings come from a Lean expert and an LLM reviewer applying this rubric independently to each anonymized artifact, with a second expert adjudicating disagreements. The per-target classification was compiled by the authors from the scored artifacts; it does not rely on any rating and can be checked directly against the anonymized Lean code. Each correction corresponds to a catalogue entry whose evidence combines formalization diagnostics with independent source review, and Lean counterexamples or exact arithmetic checks where they apply. The revised paper reports the per-task scopes and per-target outcomes in Appendix B.1. The updated supplementary materials contain the rubric and detailed expert ratings.

Thank you for your effort in improving the work! The problem you studied is indeed significant in this domain. It is a pleasure to see your response to the problems I have proposed.

Thank you for your encouraging feedback and for recognizing the importance of the problem! We appreciate your thoughtful suggestions and your time in considering our responses. Please let us know if any concerns remain or if further clarification would be helpful. We would be happy to address them.

Reviewer_FAPdOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

ProofLoom is an agentic system for formalizing research-level stochastic optimization in Lean. Its central idea is to let outstanding proof obligations determine which algorithm representations, interfaces, and supporting mathematical results must be constructed (top-down theory-building approach). As proof development progresses and some changes are needed, the "live" theory development and constructed facts, ProofLoom uses signature contracts to record the proposed changes, while the external Judge preserves faithfulness by reviewing these changes to prevent derived facts from becoming unsupported assumptions. Completed developments contribute reusable mathematics and construction records to SOptLib.

Validation includes a comparison with six baselines on fifteen tasks, a 43-case mechanism ablation, and a four-task library ablation. ProofLoom achieves mean adjudicated human ratings of 6.3/7 and 6.4/7 on textbook and research-paper tasks, respectively, versus 4.9/7 and 5.0/7 for the strongest baseline.

Critical strengths
  1. A concrete approach to controlling semantic drift during model revision: Research-level proof construction can expose inadequate definitions or interfaces, but modifying these to make a proof succeed risks changing the mathematical claim. ProofLoom addresses this directly through protected interfaces, source-linked revision contracts, explicit classification of assumptions versus derived obligations, and review of affected dependencies. The 43-case study provides targeted evidence: the full system identifies a correct diagnosis and faithful repair direction in 33 cases versus 29 for either ablation, while removing Judge increases incorrect repairs from one to six. Although these are local outcomes, they support the purpose of the proposed controls.

  2. Substantial empirical and mathematical artefacts: The 15-task comparison uses the same generation model and cumulative time limit across seven systems, with higher average human ratings for ProofLoom in both source groups. The reusable SOptLib infrastructure and detailed discrepancy catalogue add value beyond those scores. The catalogue carefully distinguishes failures of individual proof steps from counterexamples to complete claims and identifies previously corrected historical defects separately. This makes the source analysis a relevant contribution on its own.

Critical weaknesses
  1. The main comparison does not fully isolate the architectural contribution from mathematical support and resource use: ProofLoom receives accumulated SOptLib declarations and construction records, while the manuscript does not establish that strong baselines receive the same support. Appendix E.4 appropriately describes the experiment as a comparison of complete system configurations, but this limits attribution to signature contracts or proof-obligation-driven construction. Equal 48-hour ceilings also leave actual token consumption, parallel execution, and time used unclear. The four-task SOptLib ablation is useful: removing the library preserves the human ratings while increasing total tokens by 7.7%–154% (Tables 23–24). However, it starts after preparing shared task materials and does not provide a matched-support comparison with a strong baseline. In general, the evidence for the complete system is stronger than the evidence identifying which components account for its advantage.

  2. It is hard to tell from the aggregate results how completely the original theorems were formalized: Table 9 gives six ProofLoom artifacts a score of 7, eight a score of 6, and one a score of 5. However, a score of 6 can still allow some scope restrictions, regularity caveats, or additional assumptions. SAPD is a concrete example: Table 19 says that the full expected-gap and tail results remain unproved and that the light-tail condition is represented by an opaque predicate, even though the artifact contains no explicit sorry.

Questions for authors
  1. Matched support and resources: Did Archon, LeanMarathon, and the other baselines receive the same SOptLib snapshot and construction records? If not, how does a strong baseline perform with that support? Also, please also report actual cumulative generation time, token use, and continuation policies for the main comparison.

  2. Achieved theorem scope: For each benchmark task, can you identify the original target statement, the achieved statement, any additional assumptions or restrictions, and remaining source-level obligations? Specifically, how is SAPD’s incomplete expected-gap/tail coverage represented in the certification and corpus statistics? When a local source-proof gap is established, how do you distinguish a repair preserving the original theorem from a narrower theorem requiring additional premises?

  3. Mechanism ablation: How were the 43 obstruction cases selected, and were cumulative continuation budgets matched across configurations?

  4. Human-evaluation robustness: How often did the initial human and LLM ratings disagree, and how much did adjudication change the reported means?

7 comments
AuthorsOpenReview ↗

Response to Reviewer FAPd (1/3)

Thank you for the detailed review and the close attention to our appendix tables. Your questions about library access, evaluation scope, and resource use have helped us improve both the experiments and their presentation. We address each point below; the shared tables are in our general response. On presentation, we clarified Figures 1 and 2 and added the SAM model-revision example in Appendix D.2.2 (see the general response).

FAPd–Q1 (review: W1, Q1). Did Archon and the other baselines receive the same SOptLib support, and how does a strong baseline perform with it?

In the main comparison they did not: the baselines ran in their native configurations without SOptLib. SOptLib, however, is not external support. It is neither hand-written nor designed in advance: ProofLoom builds it from its own work, adding the reusable verified objects and construction records of each certified development. We regard this accumulation as part of the method, while agreeing that its effect should be distinguished from that of the workflow. The two controls below address this question.

Matched control (Table R1, new). We gave Archon the same library. On five randomly drawn benchmark tasks, ProofLoom and Archon each ran with and without SOptLib, with GPT-5.6 Sol (medium) for all four arms and a library that contains none of these tasks' own results.

  • The library changes each system's mean rating by 0.2 (Archon 4.6 → 4.8, ProofLoom 6.0 → 5.8), in both cases through a one-point change on one task.
  • ProofLoom without the library is at least as high as Archon with it on every task (equal on three, higher on two; 6.0 vs. 4.8), and the automatic scores agree (G-Eval 95.8 vs. 71.3).
  • The gap is concentrated in SCCSP and SZO; on AMSGrad, PAGE and SAPD all four arms receive the same rating. Two of Archon's five artifacts contain sorry in each arm, against none of ProofLoom's.

ProofLoom without the library (Table R5). On the four original tasks in Appendix E.6, removing SOptLib leaves every rating unchanged and raises token use by 7.7%–154%; with no library on either side, ProofLoom averages 6.75 on these tasks, against 5.00 for Archon and 5.25 for the best baseline chosen per task. The two additional pairs on ADMM and RSGD show a similar pattern: ADMM scores 6/7 in both arms, both certified, and the run without the library takes about 60% more time; on RSGD the run without the library scores 6 instead of 7, uses 8.3 times as many tokens (563.6M vs. 67.9M), and uses the full 48-hour budget.

Why the same library does little for Archon. To benefit from a library beyond Mathlib, a system must work out which results an open goal depends on, decide when consulting the library is worthwhile, and adapt what it finds to its own model; these are the steps that ProofLoom's obligation-driven construction performs. The matched control reflects this: with the library, ProofLoom's output tokens fall by 12% (on four of the five tasks), while Archon's rise by 42% (on all five).

This supports our view of the library's role: SOptLib extracts reusable infrastructure and lowers the cost of formalization, while faithfulness, and the gap to the baselines, come from Model, Construct, and Certify. Each reusable Lean declaration is stored with a natural-language construction record, so a later task recovers both a verified result and the proof obligation that motivated it.

FAPd–Q2 (review: W1, Q1). What were the actual generation time, token use, parallelism and continuation policy in the main comparison?

Table R2 now reports these for all seven systems on all 15 tasks. Every system ran in its default configuration under a cumulative 48-hour cap per task; a run continues until it completes or reaches the cap, and infrastructure downtime is excluded from the budget for every system. ProofLoom executes serially. It used 6.89B tokens over the 15 tasks, 90% of them cached input, against 6.22B for Archon and 5.03B for Trellis; its median per task (365M) is below Archon's (463M). Its median elapsed time is 19.5 hours, and 2 of its 15 runs reached the cap, against 9 for Archon (median 48 hours) and 4 for Trellis (median 29.7 hours); LeanMarathon's median is 6.9 hours.

AuthorsOpenReview ↗

Response to Reviewer FAPd (2/3)

FAPd–Q3 (review: W2, Q2). For each task, what is the original target, what was achieved, under which added assumptions or restrictions, and what remains open?

Table R3 lists, for each of the 15 benchmark tasks, the source targets and what the scored artifact proves under which conditions; Table R3-T classifies each of the 28 selected targets (a convergence bound, theorem part or main corollary; a target with several joint guarantees counts as proved only if all of them are proved). 26 are proved: 7 exactly as stated, 6 with an evidence-backed correction, 8 within a stated scope, and 5 with both. The remaining two, SAPD's Theorem 4.8(a)–(b), are open. The revised paper includes the per-task scopes and per-target outcomes in Appendix B.1.

FAPd–Q4 (review: W2, Q2). How is SAPD's incomplete expected-gap and tail coverage represented in the certification and corpus statistics?

SAPD is counted among the 33 developments and in the line count, and its two main targets are counted as open in Table R3-T. We report two things separately. Proof completeness: every proof in the 15 scored artifacts is complete, with no sorry, admit or axiom declaration. Source coverage: which source targets these complete proofs reach, reported per target in Table R3-T. A target that is not reached within the budget is stated in the artifact and reported as open, rather than closed by a placeholder or by assuming what remains to be proved. The revised paper reports target-level coverage in Appendix B.1, alongside the per-task formalization scope.

On SAPD, the scored artifact formalizes the updates, the proximal subproblems and several intermediate bounds, and proves conditional expected-gap bounds under explicit additional premises, including independence and the integrability and nonpositive expectation of the accumulated martingale residual. It also proves a general martingale tail lemma from conditional centering and exponential-moment conditions, but does not connect it to the full SAPD process. Its model queries the oracle at xtx_t rather than the source's midpoint x‾t\underline{x}_t (see the correction in our general response). Theorem 4.8(a)–(b) remain open, as does every result that depends on the light-tail condition of Assumption 9, which is encoded as an opaque predicate; the artifact is rated 5/7. The baselines illustrate why we count targets rather than endpoint declarations: Archon and Trellis use the full 48 hours and leave 5 and 10 sorry declarations, while LeanMarathon states both endpoints as theorems but takes the martingale tail inequality and the noise cancellation as hypotheses, so under our classification these endpoints would not count as proved either.

On SAPD, Archon and Trellis leave key supporting proofs incomplete. Archon leaves the measurable-selector construction in auxiliary_project_singleton_graph_selector_fallback as sorry (supplement: benchmark/tasks/SAPD/candidates/C2/Algorithms/Benchmark/StochasticAcceleratedPrimalDual/Auxiliary.lean, lines 629–639). Trellis leaves the passage from pointwise bounds to the supremum gap in SAPDGapSupremumPassage as sorry (benchmark/tasks/SAPD/candidates/C5/Tablet/SAPDGapSupremumPassage.lean, lines 5–14). Within the 48-hour scoring budget, ProofLoom completed the algorithm updates, proximal subproblems and several intermediate results. With continued development, the endpoint version proves corresponding expected-gap and high-probability bounds under explicit conditions, including a one-step tail-bound condition for the high-probability result. This demonstrates ProofLoom’s ability to advance long-horizon formalization. The endpoint version is included in the supplementary materials; the paper and Table R3-T continue to count the 48-hour scored artifact, so SAPD’s two source targets remain open in those statistics.

AuthorsOpenReview ↗

Response to Reviewer FAPd (3/3)

FAPd–Q5 (review: Q2). When a source-proof gap is established, how do you distinguish a repair that preserves the original theorem from a narrower theorem with additional premises?

We distinguish these cases by whether the discrepancy lies in the source or in the scope of the formalization. A change counts as a correction when the source claim fails as printed, or its proof does not go through, and the discrepancy catalogue (Appendix C) gives the evidence; a premise added for this reason is part of the correction, and the discrepancy is attributed to the source. A scope restriction is recorded when the formal result holds in a narrower setting than the source states, such as a finite-dimensional realization, a fixed parameter choice, a nondegenerate case or an explicitly stated regularity premise; it records a modelling choice of the formalization and makes no claim that the source is wrong. The corrected statements are proved in Lean; Appendix C gives the evidence for the source discrepancies, including the Gaussian-scale mismatch in SAM's PAC-Bayes argument (A17) and the printed inequality of SNCCG's Corollary 7.12, which a one-dimensional counterexample refutes (A01).

FAPd–Q6 (review: W1, Q3). How were the 43 obstruction cases selected, and were budgets matched across configurations? Which components account for the advantage end to end?

We selected every recorded obstruction checkpoint whose stall time exceeded a fixed threshold, fixing the case set before any ablation run. This yields 43 cases from 13 developments. For each case, all three configurations start from the same checkpoint and source material with the same 7-hour budget; cases resolved earlier stop early. Crossing requires a correct diagnosis of the root obstruction and a source-faithful repair direction, with subsequent proof obligations allowed (Table R6). Without the Judge, incorrect repairs rise from 1 to 5 among the 29 model or interface mismatches, and from 0 to 1 among the 14 false or underspecified source claims. All three configurations cross in 25 cases and none does in 9; against each ablation, the full system crosses in 5 cases where the ablation does not, and the ablation crosses in 1 where the full system does not (Table R6). The supplementary case records give the labels for every case and configuration.

To connect these local results to complete formalizations, we ran an end-to-end ablation on 11 tasks (Table R4, new). Each ablation removes one component. No ablation receives a higher rubric rating than the full system on any task. Without the Judge, ratings are lower on 8 of 11 tasks; without Planner–Audit, on 7 of 11 (mean ratings 6.36, 5.45 and 5.45). Two no-Judge and four no-Planner–Audit artifacts still contain sorry, against none for the full system. Both ablations are now in the revised PDF; in the final version we will extend them to all benchmark algorithms, rerunning every arm with the same currently available model.

FAPd–Q7 (review: Q4). How often did the initial human and LLM ratings disagree, and how much did adjudication change the reported means?

For the 15 tasks and 7 systems of the main comparison, the initial scores agreed on 89 of 105 artifacts (84.8%), and all 16 disagreements were one point apart; Cohen's κ between the two initial assessments is 0.80. Adjudication changed 10 initial human scores (7 down by one point, 3 up by one point), moving the overall mean from 4.267 to 4.229. On the textbook tasks, ProofLoom moved from 6.4 to 6.3 and Archon from 4.7 to 4.9; on the research-paper tasks they stayed at 6.4 and 5.0. ProofLoom has the highest mean in both groups before and after adjudication. The new experiments were scored with the same procedure. We have included the detailed rating records in the updated supplementary materials.

We hope these responses address your questions and concerns, and we would be glad to provide any further clarification.

Comments on the paper

6 comments
AuthorsOpenReview ↗

General response (1/5): new experiments and Table R1

We thank all reviewers for their careful reading and constructive feedback. Your questions and suggestions have helped us clarify the contribution, strengthen the experimental comparisons, and present the scope of the formalizations more clearly.

Changes in the revised PDF are marked in blue.

Since submission we have completed the following experiments under the same 48-hour cap per run:

  • a matched library control: ProofLoom and Archon, each with and without SOptLib, on five benchmark tasks (20 runs, Table R1);
  • an extension of ProofLoom's SOptLib ablation from four to six tasks, adding ADMM and RSGD (Table R5);
  • an end-to-end ablation of the Judge and of Planner–Audit on 11 tasks (22 component-ablation runs, Table R4).

The 22 ablation runs took 453 hours and 6.1B tokens, close to what ProofLoom used on all 15 main-experiment tasks (6.9B). Table R2 now reports resources for all seven systems. Further details of the experimental settings are in the README of the supplementary package. The revised PDF adds one page to the main text with the library control and the end-to-end ablation (Sections 5.3–5.4; changes are marked in blue). The library control covers five tasks and the end-to-end ablation covers eleven; in the final version we will extend both to all benchmark algorithms, rerunning every arm with the same currently available model. Our central contribution is the proof-obligation-driven co-evolution of the formal model and the proof: open obligations decide where and when the model is revised, and each revision is checked against the source when it is made. To make this clearer, we rewrote the contribution paragraph of the introduction, without changing the method, and revised Figures 1 and 2 to clarify how proof obligations guide theory construction and model revision through the Model, Construct and Learn stages. Their layout and labels are simplified; Appendices D.2.2 and D.4 explain a concrete model revision in SAM. The anonymous repository now also contains the experimental data and evidence behind these results, the Lean code of all experimental artifacts, the open-source ProofLoom system, and the human and LLM score sheets.

Table R1. Matched library control (new). We compare ProofLoom with Archon, the strongest baseline in Table 2. Five benchmark tasks drawn at random. The end-to-end ablations (R4) and the additional ADMM/RSGD library pairs (R5) were run after submission, while GPT-5.5 was still available to us. This matched control (R1) was run during rebuttal, when GPT-5.5 was no longer available to us, so all four arms use GPT-5.6 Sol (medium). The library contains none of these tasks' own results. In the SOptLib condition, Archon had full access to the library, and its prompt included neutral guidance on library use and retrieval methods. Budgets are as in the main experiment.

TaskProofLoom, with SOptLibProofLoom, withoutArchon, with SOptLibArchon, without
AMSGrad6 · 98.7 · 96.76 · 96.7 · 91.36 · 90.7 · 87.06 · 90.0 · 86.7
PAGE6 · 92.7 · 96.76 · 97.0 · 100.06 · 95.0 · 89.06 · 94.7 · 88.3
SAPD5 · 85.3 · 85.75 · 90.3 · 87.35 · 85.3 · 81.75 · 62.3 · 60.0
SCCSP6 · 98.0 · 99.77 · 98.3 · 100.03 · 46.3 · 45.02 · 36.0 · 35.3
SZO6 · 97.0 · 96.36 · 96.7 · 94.04 · 39.0 · 45.04 · 58.3 · 53.3
Mean5.8 · 94.3 · 95.06.0 · 95.8 · 94.54.8 · 71.3 · 69.54.6 · 68.3 · 64.7
Artifacts containing sorry0/50/52/52/5

Each cell: seven-point rubric rating (final, after adjudication) · G-Eval · FidelityEval (0–100, mean of three repeats).

The library changes each system's mean rating by 0.2, in both cases only through a one-point change on SCCSP, in opposite directions. On SCCSP, ProofLoom took different routes with and without the library: with it, the proof is organized through the SOptLib interfaces for Bregman divergences, proximal steps, iterates, stochastic oracles and filtrations; without it, the task file builds finite sampling paths directly on Mathlib and proves measurability, integrability, residual cancellation and the tail bounds itself. Both artifacts prove the expected gap and Proposition 4.10, and their automatic scores are nearly equal (98.0 / 99.7 vs. 98.3 / 100.0); the full ProofLoom system scored 7 on SCCSP (Table 2, GPT-5.5). This one-point difference does not show that running without the library is better; the same holds for Archon's one-point change on SCCSP. ProofLoom without the library is at least as high as Archon with it on every task (equal on three, higher on two).

AuthorsOpenReview ↗

General response (2/5): Tables R2 and R5; correction to A09

Every new artifact was scored blind with the paper's procedure: each seven-point rating follows the same protocol as the main experiment (independent initial ratings by a Lean expert and an LLM reviewer, with disagreements adjudicated by a second Lean expert), and each automatic rubric score (G-Eval, FidelityEval) is the mean of three independent repeats. The revised appendix reports task-level ratings and mean automatic scores; the supplementary data include all three individual automatic assessments.

Table R2. Resources in the main experiment, all systems (15 tasks each). Total tokens include cached input; model calls are as logged by each system. Per-task figures are in the supplementary data.

SystemTotal tokensCached shareMedian tokens per taskModel callsMedian elapsed timeRuns at the 48 h cap
Raw Codex0.12B80%7.3M150.7 h0
Raw Codex (Goals)0.19B87%9.6M1,9581.3 h0
OpenGauss0.04B94%1.4M5570.2 h0
LeanMarathon2.68B95%113.1M42,2846.9 h0
Trellis5.03B89%323.3M6,82629.7 h4
Archon6.22B94%463.4M2,25848.0 h9
ProofLoom6.89B90%364.9M58,82619.5 h2

Infrastructure downtime is excluded from the 48-hour budget for every system. Across the 15 ProofLoom tasks, Model uses 1.955B tokens (28.38%) and Construct plus Certify uses 4.934B (71.62%). Per-task stage totals and shares are in the supplementary data.

Table R5. ProofLoom with and without SOptLib (GPT-5.5). The four original pairs and two additional pairs on ADMM and RSGD, all reported in Appendix E.6. Tokens in millions.

TaskRating with SOptLibRating withoutTokens withTokens without
AMSGrad77177.90191.67
SBMD77156.98309.96
NSMD66364.92926.77
NSAGD77129.45195.81
ADMM (new)6621.3723.80
RSGD (new)7667.95563.55

Removing the library changes a rating by at most one point (RSGD, 7 → 6) and raises token use in every pair: by 7.7%–154% on the four submitted pairs, 11% on ADMM, and to 8.3 times the original total on RSGD, where the run without the library used the full 48 hours. Together with Table R1, the library never changes a rating by more than one point, for either system.

Correction to A09. We correct one entry of the discrepancy catalogue. In re-checking the source findings against the printed sources, we found that A09 is incorrect: Algorithm 4.3 queries the oracle at the accelerated midpoint x‾t\underline{x}_t (Eqs. (4.4.14) and (4.4.57)), consistent with the proof; the mismatch came from our scored SAPD model, which queried at xtx_t, not from the source. The error arose in the built-in OCR stage of our pipeline, which dropped the underline in x‾t\underline{x}_t. We withdraw A09. Because this deviation is explicit in the artifact and the rest of the model follows the source, it fits level 5 of the rubric (Table 8), with an alignment condition retained as a proof boundary; after review by the second Lean expert, the rating remains 5/7. A later SAPD development with the correct query point gives a Lean counterexample to Corollary 4.3: with the printed parameters, the smoothness term has coefficient 24, whereas Eq. (4.4.77) prints 12. The 2022 errata do not cover this, and the rate is unchanged. We add this post-submission finding as a new entry in the catalogue. SAPD's two targets remain open, as in Table R3-T. The revised PDF marks these changes.

AuthorsOpenReview ↗

General response (3/5): Table R3

Table R3. Scope of the 15 scored benchmark artifacts. Final human ratings; the last column summarizes what is proved and under which conditions, and each entry was checked by a Lean expert against the scored Lean artifact. Letters and numbers in parentheses are entries of the discrepancy catalogue (Appendix C).

TaskRatingSource targetsScope of the scored artifact
SMD6/7Lan Thm. 4.1Expected objective gap of the weighted output, with the initial Bregman and variance terms. Euclidean model; gradients on the relative interior, with the Bregman kernel extended continuously to the feasible set.
SBMD7/7Lan Alg. 4.5, Thm. 4.12Expected-gap bound derived from the block proximal update, with inverse-probability weights and variance constants. Measurability of the proximal selection and the conditional noise cancellation are proved.
SCGS6/7Lan Alg. 7.8, Thm. 7.11(a–c)Expected bounds (a) and (b) for every adapted state process of the algorithm; inner-iteration bound (c) for positive tolerance. Finite-dimensional inner-product realization.
SAPD5/7Lan Alg. 4.3, Thm. 4.8(a, b)Updates, proximal subproblems and several intermediate bounds are proved; the model queries the oracle at xtx_t rather than the source's midpoint x‾t\underline{x}_t (see the correction above). Thm. 4.8(a) (expected bound) and (b) (high-probability bound, which depends on the light-tail condition) remain open.
NSAGD7/7Lan Alg. 6.4, Thm. 6.12(a, b)Nonconvex stationarity and both convex bounds, with the original weighted output and right-hand sides. Conditional centering and second moments are required at the adaptive oracle queries, which the original proof uses (A04).
SNCCG6/7Lan Alg. 7.13, Thm. 7.17, Cor. 7.12Expected Wolfe-gap bound under a stated output-law premise (step-size domain, positive normalizer, T ≥ 2), and a corrected Cor. 7.12; a one-dimensional Lean counterexample shows that the printed inequality fails (A01, A02).
RPDG7/7Lan Alg. 5.1, Thm. 5.1Both original rates, for the expected Bregman distance and the objective gap, with Lemmas 5.1–5.5 and Prop. 5.1. The denominators in the rates are stated to be nonzero.
SCCSP7/7Seven Lan targets, incl. Lemma 4.6 and Prop. 4.10All seven targets: generated trajectory, weighted output, expected gap and constant-stepsize tail bound, with the source stepsize and exponential-moment conditions. Three of them (expected gap, constant-stepsize bound, Prop. 4.10) are main targets in Table R3-T; the other four are supporting lemmas.
NSMD6/7Lan Thm. 6.6(a), Cors. 6.6–6.7, Thm. 6.7(a, b)Expected stationarity, two-stage tail bounds and oracle complexity, including zero-threshold and zero-noise boundaries. Thm. 6.6(a) is realized with a fixed inner stepsize and batch size; Thm. 6.7(b) assumes σ > 0.
SZO6/7Lan Lemma 6.2, Thm. 6.3(a, b)Gaussian-smoothing and estimator properties, then nonconvex stationarity and convex objective-gap bounds for the generated run. C¹·¹ regularity of the expected objective is a stated premise.
AMSGrad7/7ICLR 2018 Alg. 2, Thm. 4, App. G Lemma 4The three regret terms and the projection lemma for the generated trajectory. A nonincreasing-momentum condition repairs the original telescoping argument and keeps the 2018 coefficients (B01).
STORM7/7arXiv v3 Alg. 1, Thm. 1Uniform-output identity and gradient-norm bound. The corrected inequality keeps the √M factor of the derivation and covers zero noise (A20).
SPIDER6/7arXiv v2 Alg. 1, online Thm. 15ε expected stationarity for the rounded online run of Option II, the option the proof uses (A21, A22).
PAGE6/7arXiv v3 Alg. 1, Thm. 1, Cor. 2Finite-sum Thm. 1 at the largest admissible stepsize (A18). Cor. 2 is proved in the formal model with a corrected batch condition; the correspondence to the source sampling window is a stated premise.
SAM6/7arXiv v3 Alg. 1, App. A.1 Thm. 2Updates and stopping rule; a corrected high-probability bound for a fixed parameter, with explicit loss-range and Gaussian-scale conditions (A16, A17), on the small-parameter-norm branch.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.