1 Introduction↩︎

Tables are one of the most common ways to represent information, providing a structured format for organizing data. They are widely used across real-world domains such as finance [1], healthcare [2], and scientific reporting [3], [4], making the ability to effectively perform tasks over tabular data essential. Solving table-related tasks requires several capabilities: understanding tables presented in textual formats, accurately locating and citing relevant values, and reasoning over critical values to derive correct answers. Large Language Models (LLMs) are increasingly applied to these tasks and often achieve strong performance [5]–[7], yet they still commit surprisingly basic mistakes even when the table format is correctly parsed, by referencing table content incorrectly, as illustrated in Figure 1.

A primary source of such errors is the dense and similar structure of tables, which makes it hard for models to reliably locate and cite values. For example, answering “Which country had the highest GDP growth between 2020 and 2022?” requires aligning multiple year columns across rows, where, analogous to human oversight, a slip can lead to mistakes. We refer to such failures to faithfully retrieve and cite information from the input as Data Referencing Errors (DREs). These errors can degrade response quality and sometimes final-answer accuracy, yet they are not fully captured by final accuracy metrics alone. Although prior work [8], [9] has observed DREs, analyses remain narrow, typically limited to a single model and a small set of human-annotated cases. In this work, we systematically investigate how prevalent DREs are, how they can be effectively mitigated, and how mitigating them influences final-answer accuracy.

We first categorize tabular DREs into two types: Incorrect Citation, involving individual values, and Omitted Information, involving entire relevant portions, as illustrated in Figure 1. We then employ LLM-as-a-Judge framework [10] to automatically detect DREs given a table and a generation model’s response. Upon evaluation, We find that DREs are ubiquitous across different models (from 1.7B to 20B parameters) and across diverse table-related tasks (including Question Answering, Claim Verification, and Table-to-Text). They are not effectively eliminated by either reasoning models’ self-reflection mechanisms [11]–[13] or by prompting-based approaches. For instance, Qwen3-8B [14], even with extended self-reflection, exhibits a 14.04% DRE rate (i.e., the proportion of responses containing DREs) on the WTQ [15] dataset, and still 12.50% when further prompted not to miscite or omit table content.

Incorporating DRE detection as a critic not only improves the quality of intermediate reasoning steps beyond what is captured by final-answer accuracy rewards, but also noticeably enhances overall performance. We explore two approaches. First, critic-based filtering, which selects the subset of sampled responses with minimal DREs, yields substantially higher accuracy than using all sampled responses, and can further enhance majority voting when combined. Second, rejection sampling, which repeatedly resamples response segments until the critic accepts it, obtains consistent gains and can improve accuracy by up to 11.96%. Notably, DREs are largely avoidable rather than fundamental limitations, yet rejection sampling with the critic offers a more robust way to reduce their occurrence.

Finally, given the high cost and black-box nature of using larger models as critics, we investigate the potential of small-scale LLMs (i.e., Qwen3-4B-Instruct, [14]) for detecting DREs. To this end, we construct training data from Qwen3-8B responses on the WTQ training set and adopt a two-stage training procedure: supervised fine-tuning for warm-up, followed by RLVR (reinforcement learning with verified reward, [16], [17]) to enhance robustness in DRE detection without constraining the Chain-of-Thought (CoT) format. Our experiments show that the trained Critic-4B consistently outperforms the untrained baseline both in-distribution and out-of-distribution, achieving an average improvement of 8.65% F1. Moreover, we demonstrate that this lightweight critic can mitigate DREs across different models and improve final accuracy more effectively than prompting-based methods.³

Our work shed light on the overlooked issue of data referencing errors, a unique error pattern that, while particularly common in table-related tasks, also appears in other domains. Although these broader cases are beyond the scope of this paper, we aim to inspire follow-up work to improve both critic and generation models by enhancing their data referencing capabilities.

2 Related Work↩︎

2.0.0.1 Table LLMs

Solving tabular tasks using LMs has been a long-standing research topic. Early work relied on table pre-training with specialized architectures, such as TaPas [18] and TaBERT [19]. With the scaling of general-purpose LLMs, recent methods adapt them to tabular settings through prompting [20], [21], supervised fine-tuning [22]–[24], and reinforcement learning [5]–[7]. As LLMs become increasingly powerful, particularly with the emergence of reasoning models that demonstrate strong problem-solving capabilities through extended thinking processes [14], [17], [25], they can already exhibit strong baseline performance on table tasks without task-specific training, as evidenced by [5], [6] and our experiments in Table 1. These developments call for moving beyond final-answer accuracy toward more fine-grained limitations.

2.0.0.2 Evaluation Beyond Accuracy

Most evaluation benchmarks emphasize final accuracy for simplicity, overlooking the quality of intermediate reasoning. To address this, prior work has proposed process-level reward models (PRMs, [26], [27]), which evaluate reasoning steps rather than only outcomes. Related efforts further decompose evaluation into dimensions: e.g., validity and redundancy in mathematical reasoning [28], instruction-following and truthfulness in alignment [29], and relevance and completeness in long-form QA [30]. In table reasoning, however, benchmarks still focus almost exclusively on final correctness [15], [31]. We introduce data referencing errors as a complementary dimension that captures how reliably models use table values, reflecting both intermediate reasoning quality and final performance.

2.0.0.3 Existing Work on DREs

Table-related tasks, especially Table QA, require models to use table values both completely and accurately. Prior work has recognized this need. For example, [8] analyzed 50 WTQ samples from Distill-Llama-8B [17] and found that more than 80% of errors came from incorrect locating and citation. Yet such studies do not systematically characterize DREs. Other work [6], [7] introduces auxiliary rewards to improve table referencing, but relies on supervised fine-tuning with annotated table regions. For instance, models are trained to generate special tags such as <|cell content|><|column name|> when using the specific table values needed to answer a question. In contrast, we evaluate models’ overall accuracy in referencing any table values and analyze how DREs affect performance. Our framework further supports critic-based detection that can be seamlessly integrated into existing LLMs, improving both response quality and final-answer accuracy without requiring special annotations or disrupting reasoning chains [32].

3 Characterizing DREs↩︎

3.1 Definition and Taxonomy↩︎

When answering a table-based question, LLMs are generally required to comprehend the table structure (e.g., distinguish between rows, understand column headers, and interpret each cell’s meaning within its row-column context), use table values to support reasoning, and reason over critical ones to derive the correct answer.

Recent LLMs overcome long-standing challenges in tabular data by handling diverse textual formats with large-scale pre-training [33] and enhancing logical and numerical reasoning through targeted post-training [34], [35]. However, our analysis reveals that these models, especially smaller ones, still make basic mistakes, which resemble human oversights that could have been avoided with careful attention. As shown in Figure 1, the model confuses columns or overlooks an entire row. In CoT responses, we define data referencing as the ability to correctly locate and cite information from inputs. Accordingly, errors or hallucinations in this process constitute data referencing errors (DREs).

While DREs can be found in different domains and modalities [36], [37], in this work, we focus specifically on table-related tasks. Tables are highly data-intensive and often contain many similar rows and columns [9], which makes models particularly prone to referencing incorrect data. Formally, we categorize tabular DREs based on granularity of referenced content as follows:

In this work, we systematically investigate the occurrence and impact of DREs and propose a plug-in critic module to mitigate them.

3.2 Evaluation via LLM-as-a-Judge↩︎

To reduce human effort and enable automatic evaluation of DREs, we adopt LLM-as-a-Judge [10], [38], leveraging a powerful LLM (i.e. Sonnet-3.7, [39]) to detect DREs in model responses. To match human-level annotation quality, we address the following challenges by careful designs:

In practice, the judge model is instructed to check whether a model-generated response uses table information accurately by examining the aforementioned two types of DREs—Incorrect Citations and Omitted Information. Manual inspection indicates that Sonnet-3.7 with ground truth (i.e. Sonnet-3.7+gt) achieves an accuracy of 92.67% with high consistency. Details and the full judge prompt are provided in Appendix 7.

3.2.0.1 Evaluation Metrics

To holistically evaluate the occurrence of DREs in model responses to table questions, we calculate the following metrics: \[\text{DRE Rate} = \frac{|\text{DRE}|}{|\text{Total}|},\] where \(|\text{DRE}|\) is the number of model responses containing at least one DRE. This metric measures the overall frequency of DREs. \[\text{Correct-in-DRE Ratio} = \frac{|\text{Correct} \cap \text{DRE}|}{|\text{DRE}|},\] where \(|\text{Correct} \cap \text{DRE}|\) is the number of responses whose final answer is correct despite containing DREs. This metric captures DREs that cannot be detected by evaluating final-answer accuracy alone. \[\text{DRE-in-Incorrect Ratio} = \frac{|\text{Incorrect} \cap \text{DRE}|}{|\text{Incorrect}|},\] which provides an approximation of the correlation between DREs and final answer accuracy.

3.3 Prevalence and Analysis↩︎

Now, we examine the severity of DREs. We focus on three types of table tasks: Question Answering, including WTQ [15], TableBench [31], and FinQA [1]; Claim Verification, represented by SciTab [41], where the model is asked to determine whether a given claim is supported by the table; and Table-to-Text, represented by ToTTo [42], which requires generating a textual description conditioned on the table.

We evaluate a range of popular LLMs, spanning sizes from 1.7B to 20B and covering different model families: reasoning models that characterize extended thinking processes, such as Qwen3-8B [14]; mixture-of-experts (MoE) models such as Llama4-Scout [43]; and standard LLMs such as Qwen2.5-7B-Instruct [44]. Following [31], we present tables in the JSON format, but we also experiment with CSV and Markdown formats. We further test a prompting-based method that explicitly instructs the model: Use only the table. Do not omit, miscite, or fabricate information. Ensure all cited values exactly match the table. Model responses are then evaluated using Sonnet-3.7+gt, and the results are summarized in Table 1. We have the following observations:

(1) Data referencing errors are prevalent across different models, table formats, and table-related tasks. For models, we observe that within a single model family such as Qwen3, data referencing capability improves with model size: larger models tend to produce fewer DREs. However, across different model families, this trend does not necessarily hold, as overall model capability also matters. For example, Llama4-Scout, as a non-reasoning model, shows relatively high rates of DREs (46.48%) despite its size. Additionally, results across different table formats (JSON, CSV, and Markdown) and table-related tasks demonstrate that DREs cannot be attributed to specific formats or tasks, but instead represent a general and widespread challenge.

(2) DREs persist under common mitigation strategies. First, reasoning models including Qwen3 series, Distill series, and gpt-oss-20b are featured by self-reflection [11], [17], yet they still exhibit DREs (5.71%-46.04%); in fact, once the first error is made, the model often repeats it, relying more on its own generation than on the original table (see Appendix Figure 4 for an example). Second, even explicitly prompting the model to focus on data referencing accuracy, i.e. WTQ + prompt setting, does not resolve DREs or improve final-answer accuracy. Third, Table-R1-Zero-7B [5] was trained on table-related datasets from Qwen2.5-7B-Instruct using RLVR [16]. While this specialized training improves answer accuracy, it does not effectively translate into fewer DREs, highlighting that data referencing is a separate capability that warrants further attention.

(3) DREs may also occur during the reasoning process, even when the final answer is correct. The Correct-in-DRE Ratio captures cases where the response contains DREs but still arrives at the correct final answer. This means that final-answer accuracy alone cannot guarantee the correctness of intermediate steps and the overall quality of the response. Besides, the Correct-in-DRE Ratio visibly varies across tasks. For example, SciTab shows a relatively high ratio (65.57%), because its answers are binary labels (True or False). In such cases, numerical citation errors in reasoning process may not affect the final judgment, as illustrated in Figure 5.

4 Reducing DREs with Critics↩︎

We observe that DREs do occur in incorrect cases and can negatively impact final accuracy, as shown quantitatively in Table 1 and qualitatively in Figure 1. Nevertheless, the DRE-in-Incorrect ratio should not be interpreted as indicating that this portion of incorrect answers is directly caused by DREs. This raises an important question: to what extent do DREs actually harm final accuracy? In this section, we apply Sonnet-3.7+gt⁴ as a high-quality critic to reduce DREs and explore whether this reduction translates into improvements in final-answer accuracy. We focus on three question answering datasets (WTQ, TableBench, FinQA) and three representative models (Qwen3-8B, Distill-Qwen-7B, Llama4-Scout).

4.1 Critic-Based Filtering↩︎

4.1.0.1 Method

A common application of a critic model is the Best-of-N (BoN) strategy, where an LLM generates multiple candidate responses and the critic selects the best one as the final output [11], [33], [45]. While effective in some contexts, this approach assumes that the critic is able to fully judge the correctness of each response [46] or assign highly discriminative scores across the set of responses [26], [47]. Our critic, however, is designed specifically to detect DREs and thus cannot directly determine which single response is best overall. For example, multiple responses may contain no DREs yet still produce different final answers if mistakes occur later in the reasoning stage after retrieving the correct table values.

To address this limitation, we adopt a critic-based filtering approach. Specifically, for a generation model (e.g., Qwen3-8B), we sample \(N=8\) responses per question and use the critic to select the subset of responses with the fewest data referencing errors instead of selecting only one “best” response. This design improves the overall quality of the candidate pool and enables inference-time strategies such as majority voting to operate on a higher-quality set of responses, thereby further improving final accuracy.

4.1.0.2 Metrics

We report the average accuracy of all generated responses versus that of the subset selected by the critic. We also compare these results with majority voting. Our primary focus is the DRE subset, which includes questions for which at least one response contains a data referencing error and at least one does not. This subset emphasizes data-referencing-challenging cases. To illustrate: if all sampled responses are free of referencing errors, then critic-based filtering will naturally show little or no improvement. Conversely, if all responses contain referencing errors, no selection strategy can guarantee correctness. Results on the full evaluation set are also reported in Appendix Table 5 but may underestimate the critic’s impact.

4.1.0.3 Results

From Table 2, we can observe that critic-based filtering steadily outperforms the average accuracy of all sampled responses by selecting those with fewer data referencing errors. This indicates that reducing DREs not only improves the quality of intermediate reasoning with fewer hallucinations but also translates into higher final accuracy. More encouragingly, it complements majority voting as an inference-time strategy: applying majority voting within the critic-filtered subset achieves the best performance, consistently surpassing majority voting alone. In some cases like Llama4-Scout on WTQ, even randomly selecting a response from the critic-filtered subset yields higher average accuracy than majority voting.

4.2 Rejection Sampling↩︎

4.2.0.1 Method

Another application of the critic model is rejection sampling. In standard LLMs, rejection sampling resembles BoN [33], [45]. In the context of reasoning models, this approach can be inefficient, as the responses of reasoning models are often very long [40], [48] and thus costly to generate when sampling \(N\) full completions. Moreover, repeated sampling increases computational expense.

We adapt rejection sampling for reasoning models by working at the segment level. Similar to Section 3.2, for a generation model such as Qwen3-8B, we split a response into segments using the delimiter “Wait”. Instead of regenerating an entire response, we selectively resample only the segment (or, when necessary, the entire response) until it passes the critic or reaches a maximum retry limit \(N=8\) is reached. The model then continues with the next segment, repeating this process until the final answer is produced. This design reduces the cost of rejection sampling while preventing error propagation across the reasoning process.

4.2.0.2 Metrics

We report accuracy using rejection sampling on the DRE subset and the full set.

4.2.0.3 Results

As shown in Table 3, rejection sampling with the critic effectively improves final accuracy for both reasoning and non-reasoning models. As expected, the improvement is larger on the DRE subset than on the full set, since data referencing errors are more likely to appear in the DRE subset. It is important to note that the rejection sampling process does not alter the generation model itself. A DRE-free response can be obtained by simply resampling. This highlights that DREs are largely avoidable errors rather than fundamental limitations of the model’s knowledge or reasoning ability. However, how to reliably reduce the frequency of DREs remains an open problem, and rejection sampling with a DRE detection critic provides a promising and practical solution.

5 Training a Small-Scale Critic↩︎

In practice, ground-truth answers are often unavailable to the critic particularly during inference, and Sonnet-3.7 is both a black-box and costly to use. Therefore, in this section, we explore the feasibility of training a smaller-scale LLM (e.g. Qwen3-4B-Instruct) to perform the critic task.

5.1 Small Critic Training↩︎

For the critic model, similar to Section 3.2, its task is as follows: given a table, a question based on the table, and a model’s response segment, determine whether the response contains DREs (See Appendix Figure 6 for the complete critic prompt). The output is either True (contains DREs, treated as positive samples) or False (does not contain DREs, including cases where no table values are cited, treated as negative samples). Beyond directly using Qwen3-4B-Instruct, we introduce a two-stage training pipeline to further enhance its ability to detect DREs.

5.1.0.1 (1) SFT.

We begin with supervised fine-tuning (SFT) as a warm-up stage to adapt Qwen3-4B-Instruct more effectively to the critic task. Although it already demonstrates strong instruction-following ability, we observe that training with RL directly, that is, without an SFT warm-up, causes the model to produce malformed outputs such as repeated <judgment></judgment> tags. To solve this, we use judgments from Sonnet-3.7 as distillation data in the first stage. This not only teaches Qwen3-4B-Instruct the expected output format but also transfers potentially useful “critic heuristics” from a stronger model, thereby stabilizing subsequent RL training.

5.1.0.2 (2) RLVR.

In the second stage, we employ reinforcement learning to enhance the critic model’s robustness and generalization. Building on SFT foundation, RL enables exploration beyond the limitations of fixed supervision. We apply Reinforcement Learning with Verified Reward (RLVR, [16], [17]), which is well suited to our setting: it leverages verified binary labels as reward signals and does not require constraining the CoT. This allows the critic to better detect DREs across diverse tasks.

For training data, we build on Qwen3-8B’s responses to the WTQ training set. We use Sonnet-3.7 to label all response segments, yielding a balanced dataset of 2,000 positive and negative samples for SFT, and 5,712 samples for RL training. The critic model trained using this data is called Critic-4B. In addition, we construct synthetic positives by inserting four types of DREs with rule-based heuristics (Appendix 9), which reduces reliance on larger models and improves efficiency in both speed and cost. The critic model trained using the synthetic data is called Critic-4B-Synthetic.

5.2 Critic Evaluation↩︎

To evaluate a critic’s performance on the DRE detection task, we construct a critic evaluation dataset. In details, we collect real positive and negative response segments, judged by Sonnet-3.7+gt, from the three models (Qwen3-8B, Distill-Qwen-7B, Llama4-Scout) across the three datasets (WTQ, TableBench, FinQA). This setup allows us to cover both reasoning (Qwen3-8B, Distill-Qwen-7B) and non-reasoning models (Llama4-Scout), as well as a diverse range of table-related question answering tasks spanning general-domain benchmarks and financial reasoning. For each model-dataset pair, we randomly sample 400 response segment with a balanced number of positive and negative examples, resulting in a total of 3,600 samples. We report the standard F1 score for this binary classification task, which balances precision (how often predicted DREs are correct) and recall (how many true DREs are identified).

5.2.0.1 Results

We compare the critic performance of Qwen3-4B-Instruct, Critic-4B-Synthetic, Critic-4B. The evaluation results are presented in Figure 2. We have the following findings:

Critic-4B consistently outperforms the untrained baseline Qwen3-4B-Instruct across all scenarios, achieving 78.16% overall F1 compared to 69.51%. Although it is trained only on the responses of Qwen3-8B on the WTQ training set, Critic-4B generalizes well to the same model’s responses on other table-related tasks. This is particularly notable because TableBench and FinQA’s tables differ significantly from those in WTQ. In addition, Critic-4B achieves high F1 in identifying DREs in the responses of other models as well.

However, Critic-4B-Synthetic, trained on synthetic data, shows larger gains on in-distribution data, i.e. on the same model or the same dataset. Yet, for settings with larger differences, such as FinQA (a different domain) and Llama4-Scout (non-reasoning model), critic performance actually declines. This suggests that the model may have overfit to biases specific to the synthetic data rather than learning to generalize to real-world errors.

5.3 Rejection Sampling↩︎

We also examine whether our trained small-scale critic, Critic-4B, can assist inference, using rejection sampling as described in Section 4.2. We report both accuracy and DRE rate (on the full set) with and without rejection sampling.

As shown in Table 4, rejection sampling with Critic-4B consistently achieves higher accuracy compared to the setting without rejection sampling. Although it is less effective than the stronger critic, Sonnet-3.7+gt (refer to Table 3), Critic-4B offers a lightweight and cost-effective alternative. Encouragingly, Critic-4B is smaller than all three generation models and does not benefit from the extended thinking processes as reasoning models like Qwen3-8B and Distill-Qwen-7B, yet it is still able to improve their accuracy. In addition, the DRE rate decreases when using rejection sampling, indicating that the critic not only enhances final-answer accuracy but also improves the overall quality of the model responses by reducing DREs.

6 Conclusions↩︎

We show that data referencing errors (DREs) are a pervasive weakness of LLMs on table reasoning tasks, undermining both response quality and final accuracy. By systematically analyzing DREs via LLM-as-a-Judge, we demonstrated their prevalence and propose inference-time strategies and lightweight critics to mitigate them. Our findings establish data referencing as a key evaluation dimension beyond final-answer accuracy for developing more reliable table reasoning systems.

Limitations↩︎

Several limitations remain that warrant future study. First, we focus solely on DREs in table-related tasks, as they are a common and non-negligible issue. However, we recognize that DREs also arise in other domains and modalities. For instance, [36], [49] describe the case: He makes 48 total ice cubes, including 10 giant cubes, 14 small cubes, 12 medium cubes, and some tiny cubes. Qwen3-8B sometimes mistakenly interprets the order as giant, medium, small, tiny, which leads to errors. We hope future work can generalize to such broader domains.

Second, we did not examine the causes of DREs from an interpretability perspective. In preliminary experiments, we did observe that when the model prepared to reference a table value, increasing its attention to the entire table helped reduce subsequent errors, suggesting that DREs are linked to insufficient attention. However, due to resource constraints, we did not scale up attention analyses or steering experiments. Future work could build on this direction.

Acknowledgments↩︎

We are grateful to Robin Jia, He Wang, and Zelin He for their insightful feedback and discussions throughout this work. We also thank the anonymous reviewers for their constructive comments.

7 LLM-as-a-Judge↩︎

The complete judge prompt for Sonnet-3.7+gt is shown in Figure 3. Note that we provide ground-truth answers to mitigate false negatives, as explained in Section 3.2. We also explicitly instruct the judge to focus solely on comparing the model response with the table data in order to assess table-referencing accuracy. With this explicit instruction, we find that Sonnet-3.7+gt remains unbiased: it distinguishes reasoning mistakes from genuine DREs rather than assuming that every wrong final answer reflects a DRE. A case of Sonnet-3.7+gt’s judgment is shown below:

While the final answer differs from the reference answer, this appears to be a calculation error rather than a table referencing error. The model accurately extracted and cited all relevant values from the table.

We randomly sampled 100 instances from the critic evaluation dataset and three annotators at the PhD level independently assessed whether Sonnet-3.7+gt’s judgments were correct. Their assessments yielded an average accuracy of 92.67%, indicating near-human reliability.

8 Critic-based Filtering↩︎

9 Synthetic Positives Construction↩︎

We use four strategies to insert DREs given a table and a model’s response with correct final answers:

We then use Qwen3-8B to perform inference for three times again to see whether the answer changes, and only save the cases where the final answer differs. For each saved case, this indicates that the modified table with the original model response, or the original table with the modified response, do not fully match—i.e. there are DREs.

10 Training Details↩︎

For SFT, we use Llama-Factory [50] with a learning rate of 1e-5, a batch size of 8, 2,000 training examples, and train for 2 epochs. For RLVR, we use verl [51], adopting GRPO [52], with a batch size of 256 and 8 rollouts per prompt at a temperature of 1.0. The learning rate is fixed at 1e-6, and we train for 20 epochs. During inference, we apply greedy decoding for the trained critic.

11 Generation Details↩︎

Except for ToTTO, we use string matching to compare accuracy across different table-related tasks. For ToTTO, following [5], we use \((\text{BLEU} + \text{ROUGE-L}) / 2\). For TableBench, we focus only on the Fact Checking and Numerical Reasoning subsets (493 in total), as the other two subsets, Data Analysis and Visualization, are beyond the tested models’ capabilities.

All generation models perform inference with their recommended decoding hyperparameters, as detailed in Table 6. For Llama4-Scout, we use the fp4 quantized version.⁵

12 Code of Ethics↩︎

All datasets and models we use are public. No ethical, safety, or privacy risks are involved in this study.

The licenses of the datasets and models we use are listed in Table 7.

This paper used LLMs to polish writing. All original content came from the authors themselves.

None

None

None

References↩︎

---

1. Work done during an internship at Amazon. Email: yyang063@usc.edu.↩︎

2. Corresponding author. Email: qzhuamzn@amazon.com.↩︎

3. Our code is available at https://github.com/ayyyq/table-referencing.↩︎

4. Although provided with ground truth answers, Sonnet-3.7 does not directly judge final-answer correctness (see Appendix 7). We use Sonnet-3.7+gt to approximate the upper bound of a DRE detection critic.↩︎

5. https://huggingface.co/nvidia/Llama-4-Scout-17B-16E-Instruct-FP4↩︎