What is StepFun-Prover-Preview-32B?
StepFun-Prover-Preview-32B is an open-weight language model from StepFun whose primary purpose is formal theorem proving. Rather than focusing on general conversation, image understanding, or broad software assistance, it is optimized to generate proofs in Lean 4, a proof assistant that checks whether a mathematical argument follows the rules of a formal system.
In ordinary mathematical writing, a plausible-looking proof may contain an unnoticed gap. Lean 4 instead evaluates the proof and reports whether it is valid, which makes it useful for mechanically verified mathematics. StepFun-Prover-Preview-32B is designed around this verification loop: it proposes proof code, receives feedback from Lean, and attempts to correct incomplete or invalid work.
The model is described as a 32-billion-parameter model, while the Hugging Face material lists approximately 33B parameters. This difference reflects how the model is described in different published materials rather than two separate editions. It is distributed under the Apache 2.0 license through the StepFun organization on Hugging Face.
How the proof-generation workflow works
The important distinction between this model and a general-purpose chat model is its intended interaction with a proof environment. A typical workflow begins with a mathematical statement expressed in Lean 4. The model generates a partial proof or proof sketch, which is then evaluated by Lean. The resulting feedback can identify syntax errors, failed tactics, unsolved goals, or other problems. The model uses that information to produce a revised attempt.
The published usage pattern uses special markers for proof sketches and Lean REPL feedback. This gives the model structured information about what happened during verification instead of asking it to judge its own answer only from text. In practical terms, the model is best understood as one component in a generate-check-repair pipeline.
This approach is especially relevant for proof repair. If a proof is nearly complete but fails because a goal remains or a tactic does not apply, the Lean feedback provides a concrete target for the next generation step. Success still depends on the quality of the theorem statement, the available Lean environment, imported libraries, prompting format, and inference configuration.
Benchmark results and what they mean
StepFun reports a 70.0% Pass@1 result on the miniF2F-test benchmark. The evaluation used interaction with a Lean 4 REPL and multiple responses per problem to estimate Pass@1. The reported result therefore reflects a tool-assisted theorem-proving setup, not simply one unrestricted text completion per question.
StepFun also reports a clear relationship between the maximum generation length and measured performance in the tested configuration. The score increased from 58.3% with a 4,096-token maximum generation length to 70.0% with a 20,480-token maximum. Longer generation gives the model more room to explore a proof, recover from failed attempts, or complete a lengthy formal argument, although it can also increase latency and resource consumption.
These are provider-reported benchmark results rather than a guarantee for every theorem or deployment. Results may differ when the Lean version, libraries, prompting format, sampling settings, hardware, or verification loop changes.
Technical specifications and modalities
| Specification | Reported detail |
|---|---|
| Provider | StepFun |
| Model size | 32B in the model name; approximately 33B in Hugging Face information |
| Model type | Reasoning-oriented causal language model |
| Context length | 20,000 tokens in the published evaluation configuration |
| Maximum tested generation length | 20,480 tokens |
| Input | Text, including Lean statements, proof context, and environment feedback |
| Output | Text, primarily Lean proof code and related reasoning |
| License | Apache 2.0 |
| Availability | Open weights through Hugging Face |
The 20,000-token context figure is the context window reported for the published evaluation, while 20,480 tokens is the highest tested maximum generation length. These figures should not be treated as evidence that every deployment will expose identical memory or serving limits. A practical installation also needs enough hardware and configuration to run a model of this size, but the supplied sources do not establish a single minimum hardware requirement.
The model has text input and text output only. It does not provide documented native image, audio, or video input or output. Its tool-related behavior is specialized: the model is intended to work with a Lean 4 REPL, but that should not be confused with a general hosted function-calling or web-search API.
Pricing and deployment
No official StepFun hosted token pricing was verified for this model. Because the weights are downloadable, the main cost model is self-hosting: users provide the compute, storage, serving software, and operational maintenance. This can be attractive for research groups that need control over the proof environment or want to avoid sending formal problems to a third-party service, but it does not mean inference is free.
Official examples show deployment with Transformers, vLLM, and SGLang. These options support different serving and integration patterns, but the model remains a self-hosted artifact rather than a documented StepFun-managed inference endpoint. Users should verify the repository's current instructions and compatibility requirements before selecting a serving stack.
The Apache 2.0 license permits broad use subject to the license terms. It does not remove the need to review the model repository, dependencies, infrastructure costs, and any obligations associated with the mathematical datasets or surrounding software used in a particular project.
Strengths and limitations
Main strengths
- Specialization: The model is focused on Lean 4 theorem proving rather than general-purpose chat, making its behavior more directly relevant to formal mathematics.
- Verification-aware workflow: It is designed to incorporate Lean REPL feedback and revise proof attempts instead of stopping after an unchecked answer.
- Open-weight access: Researchers and developers can run it locally or on their own infrastructure using the published deployment examples.
- Long proof-generation budget: The reported 20,480-token maximum generation setting provides room for multi-step proof search, subject to hardware and serving constraints.
- Reproducible formal target: Lean's checker provides a concrete validity test for generated proof code.
Main limitations
- Narrow domain: The model is primarily useful for formal theorem proving and should not be assumed to match general instruction-following models on everyday writing, broad knowledge tasks, or application assistance.
- No managed API pricing or interface verified: Users seeking a simple pay-as-you-go endpoint will need another option or must operate the model themselves.
- Compute and latency: A model in the roughly 32B-to-33B parameter class is more demanding to serve than smaller models. The reported speed assessment is editorial rather than a provider-published latency guarantee.
- Environment dependence: Successful proof generation depends on Lean versions, imports, libraries, prompts, and the exact feedback loop. A proof that works in one environment may require adjustment in another.
- No documented multimodal or general tool interface: Its Lean integration does not establish image understanding, speech capabilities, web search, native JSON mode, or generic function calling.
Reasoning, coding, speed, and cost trade-offs
StepFun-Prover-Preview-32B's reasoning strength is best evaluated through formal proof completion rather than ordinary conversational benchmarks. Its defining capability is the combination of mathematical search and external verification. It can spend many generation steps exploring a proof, then use Lean's response to guide repair. That makes it a strong candidate for proof synthesis and formalization workflows where correctness is checked mechanically.
It is also capable of producing code, but its coding role is specialized. Lean proof scripts are programs interpreted by a formal environment, so the model's coding value is concentrated in theorem statements, tactics, lemmas, and proof repairs. It should not automatically be selected as a primary model for general application development, codebase maintenance, or multimodal programming assistance.
There is a direct capability-versus-speed trade-off. A large model with a long generation allowance can explore more proof paths, but self-hosted inference may be slower and more expensive than using a smaller model or a managed general-purpose service. The supplied editorial assessment rates reasoning at 9, coding at 7, speed at 4, and cost at 9; these are subjective catalog scores, not provider-published benchmark measurements. They summarize the model's intended value for reasoning and open-weight cost control while acknowledging its likely serving burden.
When to choose this model
Choose StepFun-Prover-Preview-32B when the central task is generating, completing, or repairing Lean 4 proofs and you can operate a local or self-hosted inference setup. It is particularly suitable for:
- research on automated or semi-automated theorem proving;
- formalization projects using Lean 4;
- proof repair driven by compiler or REPL feedback;
- experiments requiring open weights and control over the verification environment; and
- batch exploration of mathematical proof candidates where machine checking is part of the workflow.
Another type of model may be more appropriate when the task requires fast interactive chat, a managed API, current web information, image or audio processing, broad software engineering, or a documented native structured-output interface. A smaller model may also be preferable when serving latency and hardware cost matter more than extended proof search. Conversely, a general-purpose model can propose useful mathematical ideas, but it will not replace the Lean-centered generate-check-repair workflow for machine-verified proofs.
Bottom line
StepFun-Prover-Preview-32B is a specialized open-weight model for Lean 4 formal mathematics, not a general AI assistant. Its strongest practical distinction is the intended loop between proof generation and Lean verification, supported by a reported 70.0% miniF2F-test Pass@1 result and a long tested generation limit. The trade-off is operational: users must self-host the model and manage the proof environment, and the model's specialization limits its usefulness for multimodal, web-connected, or general-purpose workloads.