🤖 machine learning

Towards Functional Correctness of Large Code Models with Selective Generation

This paper proposes "FuzzEval," a paradigm that leverages dynamically generated unit tests to enable a selective code generator to abstain from uncertain outputs, thereby theoretically controlling the false discovery rate and improving the functional correctness of large code models.

Original authors: Jaewoo Jeong, Taesoo Kim, Sangdon Park

Published 2026-06-16

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Jaewoo Jeong, Taesoo Kim, Sangdon Park

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a very talented but slightly overconfident robot assistant whose job is to write computer code for you. You ask it, "Write a program that sorts a list of names," and it happily spits out a solution. But here's the catch: sometimes, this robot is hallucinating. It writes code that looks like it works, but when you actually run it, it crashes, gives the wrong answer, or does something completely unexpected.

In the world of software, this is dangerous. You can't just trust the robot blindly.

This paper introduces a new "safety inspector" system for these code-writing robots. Instead of just accepting whatever code the robot generates, this system acts like a strict quality control manager who says, "I'll only let the good code through; if I'm not sure, I'll admit I don't know."

Here is how the system works, broken down into simple concepts:

1. The Problem: The "Black Box" of Code

Usually, when we check if a piece of code is good, we rely on a few pre-written tests (like a checklist). But for complex problems, a checklist might miss hidden bugs. It's like checking if a car is safe by only looking at the tires and ignoring the engine. The paper argues that because code is so complex and "unnatural" for humans to read, it's hard to tell if two pieces of code do the exact same thing just by looking at them.

2. The Solution: The "Fuzzing" Machine

To solve this, the authors use a tool called Fuzzing. Imagine you have a machine that takes a piece of code and throws millions of random, weird, and extreme inputs at it, just to see if it breaks.

The Analogy: Think of a stress-tester for a bridge. Instead of just driving one car across, the machine throws sandbags, heavy trucks, and even elephants across the bridge in random patterns to see if it holds up.
The Result: This machine automatically generates thousands of "unit tests" (little scenarios to check the code) that the robot never saw before.

3. The "Selective Generator": The Honest Robot

The paper proposes a new way to use the code-writing robot. They add a "gatekeeper" step.

The Process: The robot tries to write code. Then, the "Fuzzing Machine" immediately tests it against thousands of random scenarios.
The Decision:
- If the code passes the tests with high confidence, the gatekeeper says, "Go ahead, this is good!" and gives you the code.
- If the code fails or the tests are too ambiguous, the gatekeeper says, "I don't know," and refuses to give you the code.

This is called Selective Generation. The robot is allowed to say "I don't know" instead of guessing and giving you bad code.

4. The Guarantee: The "False Discovery Rate"

The most exciting part of the paper is the math behind the gatekeeper. The authors don't just hope the system works; they prove it mathematically.

They set a rule: "We want to make sure that less than 30% (or whatever number you choose) of the code we do give you is actually bad."
They call this the False Discovery Rate (FDR).
The system is designed so that even if the robot is terrible, the gatekeeper will filter out the bad stuff so strictly that the final batch of code you receive is guaranteed to be mostly correct.

5. FuzzEval: A Better Report Card

Finally, the authors suggest using this same "Fuzzing Machine" to grade code models in the future. Instead of just checking if code passes a few standard tests (like a school exam with 5 questions), they propose using the Fuzzing Machine to generate hundreds of random tests. This gives a much more accurate and rigorous report card on how good a code-writing AI really is. They call this new grading method FuzzEval.

Summary

In short, this paper teaches us how to build a safety net for AI code generators. By using a "stress-test" machine (Fuzzing) to automatically create millions of tests, we can create a system that:

Filters out bad code before it reaches you.
Admits ignorance ("I don't know") when it's unsure, rather than hallucinating a wrong answer.
Guarantees mathematically that the code you do get is safe to use.

It turns a "guess and hope" approach into a "test and verify" approach, making AI-generated code much more reliable for real-world use.

Technical Summary: Towards Functional Correctness of Code Models with Selective Generation

Problem Statement

Large Language Models (LLMs) have demonstrated significant performance in code generation tasks; however, their applicability in safety-critical systems is hindered by "code hallucination," where generated code fails to satisfy desired functional specifications. A critical bottleneck in mitigating this issue is the difficulty of identifying the functional correctness of generated code. Unlike natural language, where semantic entailment can be annotated by humans, code possesses a complex, unnatural structure that makes manual verification of functional equivalence challenging. Existing benchmarks often rely on limited, manually curated unit tests, which may not cover sufficient execution paths to guarantee correctness. Furthermore, current methods for controlling hallucination often focus on improving model performance via fine-tuning or ranking, lacking direct, theoretically grounded mechanisms to control the rate of false outputs during inference.

Methodology

The authors propose a framework for Selective Code Generation that theoretically controls the rate of hallucination using a False Discovery Rate with Code Entailment (FDR-CE) metric. The methodology consists of three core components:

1. $\alpha$ -Code Entailment and Fuzzing

To address the difficulty of defining functional correctness, the paper redefines entailment for code using the executable nature of programs.

$\alpha$ -Code Entailment: Instead of requiring exact equivalence, the authors define a code snippet $\hat{y}$ as $\alpha$ -entailed by a unit test generator $F(x)$ if the probability of $\hat{y}$ passing the tests is at least $1-\alpha$ . This allows for a probabilistic measure of functional correctness.
FuzzEval: To generate the necessary unit tests automatically and rigorously, the authors employ fuzzing, a dynamic code analysis technique. By randomly sampling and mutating input seeds, fuzzing explores a wide range of execution paths to generate input-output pairs. This process, termed FuzzEval, serves two purposes:
- Learning: Generating a large set of unit tests to estimate the entailment set for training the selective generator.
- Evaluation: Providing a more rigorous evaluation benchmark than static, manually curated tests.

2. Selective Generation Framework

The system introduces a selective generator $\hat{S}(x)$ that acts as a post-processor for a base code generator $G(x)$ .

Abstention Mechanism: For a given prompt $x$ , the system calculates a score $f(x, G(x))$ (e.g., length-normalized log-probability). If the score exceeds a calibrated threshold $\tau$ , the code is returned; otherwise, the system abstains (returns "I don't know").
Risk Control: The goal is to ensure that the probability of the selected code being functionally incorrect (i.e., not $\alpha$ -entailed) remains below a desired level $\epsilon_S$ . This is formalized as controlling the FDR-CE:
$R_\alpha(\hat{S}) := P\{ \hat{S}(x) \notin E_\alpha(x) \mid \hat{S}(x) \neq \text{IDK} \}$
where $E_\alpha(x)$ is the set of code snippets that satisfy the $\alpha$ -entailment condition.

3. Theoretical Guarantees and Algorithm (ASCG)

The authors propose the ASCG (Algorithm for Selective Code Generation) learning algorithm.

Estimation: Since the true entailment set $E_\alpha$ is unknown, the algorithm uses a lower binomial tail bound $\hat{L}$ derived from the generated unit tests to estimate the entailment set $\hat{E}_{\alpha, \epsilon_E}$ .
Calibration: Using a calibration set, the algorithm searches for an optimal threshold $\tau$ that minimizes the threshold (maximizing selection efficiency) while ensuring the upper bound of the FDR-CE does not exceed the target $\epsilon_S$ .
Guarantee: Theorem 4.3 provides a theoretical guarantee that the learned selective generator satisfies the desired FDR-CE constraint with high probability ( $1-\delta_S$ ), even without human-annotated entailment labels.

Key Contributions

Selective Generation for Code: The paper extends the concept of selective prediction (previously applied to natural language) to code generation, introducing a mechanism to control hallucination rates via abstention.
FuzzEval Paradigm: It proposes using fuzzing tools to automatically generate unit tests for both learning the selection function and evaluating code correctness, overcoming the limitations of small, manual test suites.
Theoretical Control of FDR-CE: The work provides a learning algorithm with a PAC-style guarantee, ensuring that the rate of falsely generated code (among non-abstained answers) is bounded by a user-defined parameter.
$\alpha$ -Code Entailment Definition: It formalizes a probabilistic definition of code correctness suitable for automated analysis, bridging the gap between semantic entailment in NLP and functional equivalence in code.

Experimental Results

The authors evaluated their method on diverse setups, including:

Models: Four code generators (GPT-4o, Gemini 1.5 Pro, GPT-4.1, CodeLlama 13B, DeepSeek-R1).
Datasets: Four benchmarks (APPS, Mercury, HumanEval, MBPP) converted to "Fuzz" versions (APPS-f, etc.) using automatically generated unit tests.
Languages: Python, C++, Java, JavaScript, and Perl.

Key Findings:

Controllability: The proposed method (SCG) successfully bounds the FDR-CE to the desired level ( $\epsilon_S$ ) across various models and datasets, whereas baseline methods (e.g., SCG-EM, SCG-manual) either fail to bound the risk or exhibit trivial efficiency (abstaining too frequently).
Efficiency: SCG achieves reasonable selection efficiency (the ratio of non-abstained answers) while maintaining the safety guarantee. For instance, on GPT-4o with $\epsilon_S=0.3$ , SCG maintained an FDR-CE below the target while retaining ~33-50% of generated answers, depending on the dataset.
Benefit of Fuzzing: Experiments demonstrated that using fuzzing-generated unit tests (SCG) significantly outperforms methods using limited manual tests (SCG-small) or no tests (SCG-EM) in terms of both risk control and efficiency.
Extension to Prior Work: The method acts as a post-processor that can be applied on top of existing advanced models (e.g., DeepSeek-R1 with GRPO fine-tuning) or ranking-based methods, providing an additional layer of statistical safety guarantees.

Significance and Claims

The paper claims that its primary contribution lies in the selective generation learning algorithm that directly controls the hallucination rate of code models. By leveraging the executable nature of code through fuzzing, the authors argue that it is possible to move beyond heuristic performance improvements to theoretically controlled safety.

The significance of the work is framed as providing a "controllability guarantee" on the False Discovery Rate, making code generators more trustworthy for systems requiring higher safety standards. The authors modestly note that while the method controls the hallucination rate, the overall selection efficiency is still dependent on the underlying quality of the code generator, and the i.i.d. assumption for the theoretical guarantee may limit applicability in distribution-shifting environments. The work does not claim to eliminate hallucination entirely but rather provides a mechanism to manage and bound it with statistical rigor.