Faulty Premises Bench (FPBench)

• Faulty Premises Bench (FPBench) is a systematic benchmark that defines and evaluates models’ ability to recognize and handle queries containing false assumptions.
• It integrates datasets across textual, code, and multimodal domains using tailored taxonomies, rigorous annotation, and standardized evaluation metrics.
• FPBench advances model robustness by assessing FPQ detection accuracy, rebuttal explanation quality, and error resistance in diverse application scenarios.

Faulty Premises Bench (FPBench) is a class of systematic benchmarks developed to evaluate the ability of models—typically LLMs, large multimodal models (LMMs), or code generators—to robustly detect, explain, and resist answering queries or tasks that contain false presuppositions, known as false premise questions (FPQs). FPBench benchmarks aim to surface and quantify models’ susceptibility to hallucination, knowledge errors, or semantically inappropriate completions caused by accepting faulty premises. This paradigm has catalyzed both the construction of high-quality datasets and the design of tailored evaluation protocols across textual, code, and multimodal (e.g., images) domains.

1. Foundational Concepts and Definitions

A question or prompt exhibits a false premise if it contains an assumption that is untrue regarding the relevant context or environment; “How many eyes does the sun have?” presumes the sun possesses biological features. In FPBench benchmarks, the critical characteristic is that the model must recognize the invalidity of the underlying premises and either refuse to answer, rebut the falsehood, or otherwise handle the query in a semantically responsible way, instead of answering according to the superficial pattern.

The formal logic of FPQ detection can be posed as a binary classification: given a query $Q$, predict $y\in\{\text{FPQ},\,\text{TPQ}\}$, where TPQ denotes a “true-premise question.” Many FPBench datasets pair each FPQ with (1) one or more gold “rebuttal” explanations and (2) a corrected TPQ, enabling multitask evaluation of both detection and explanation.

2. Dataset Construction and Taxonomies

FPBench instantiations have been developed in several modalities, each employing rigorous annotation or automated transformation to synthesize challenging FPQs and matched true-premise controls.

Textual QA—FalseQA

• 2365 human-written FPQs, annotated with one or two gold rebuttal explanations, a minimally edited true-premise question (TPQ), and a gold answer to the TPQ. Twenty trained annotators operated under a taxonomy of eight error types (Property, Action, Scope, Entity, Event, Logic, Causality, Index) and six question formats (Descriptive, Factual, Enumerative, Selective, Hypothetical, Yes/No). Each FPQ was manually edited and labeled following 29 seed questions and type definitions (Hu et al., 2023).
• Train/dev/test splits: 1187/491/687 FPQ-TPQ pairs; mean length per FPQ ~10.6 tokens, per explanation ~12.1 tokens.
• Rebuttal explanations must name and refute the false premise, e.g., “The sun is a star, not an animal, so it has no eyes.”

Knowledge Graph–Driven QA—KG-FPQ

• Automated generation of ~178,320 FPQs by mutating Wikidata triples within three domains (Art, People, Place) via six controlled editing types (NSC, NDC, NNSC, NNDC, NNSR, NNDR), stratified by graph distance and conceptual association (Zhu et al., 2024).
• For each source triple $(h, r, t)$, up to six false triples are generated by substituting $t$ with $t'$ according to confusability criteria, with both Yes/No and WH-formulated questions produced via GPT prompting.
• Enables scaling to six levels of confusability and two task formats (discriminative and generative).

Multimodal (Vision+Language)—FP-RefCOCO(+/g)

• Extension of referring segmentation datasets (RefCOCO, RefCOCO+, RefCOCOg) with context-aware negative referring expressions, automatically created by minimally replacing an object, attribute, or relation in annotated queries, paired with corrected ground-truth references. Resulting in 19,992–25,799 images and 186,250–276,930 sentences per variant, with a balanced positive:negative ratio (Wu et al., 2023).

Code Generation—FPBench for Code

• Definition of faulty premise classes for code: Rule-Based Deletion (RUD), Unrelated Perturbation Insertion (UPI), Random-Based Deletion (RAD). Datasets constructed by injecting perturbations into 1800 base coding problems (HumanEval, MBPP+), covering all three premise-defect categories (Li et al., 5 Aug 2025).

3. Benchmark Tasks and Evaluation Metrics

FPBench protocols employ principled, multi-axis evaluation targeting both detection of faulty premises and the model’s ability to rebut or avoid hallucinated completions:

Task	Mode	Core Metric(s)
FPQ Detection	Discriminative	Accuracy, Recall, Precision
Rebuttal Explanation	Generative	ROUGE-L (text), CLAIR score (vision), Human Adequacy
True-Premise Question Answering	Generative	Exact Match, F1 (ARC-DA)
Code Fault Detection	Discriminative/Proactive	Error Report Rate (PRER, PAER), Output Overhead Ratio
Segmentation under FP	Multimodal	cIoU (cumulative Intersection-over-Union)

Textual benchmarks use binary classification loss $$L_{\text{disc}} = \mathrm{CrossEntropy}(\sigma(W \cdot h_Q), label)$$ and standard sequence-to-sequence cross-entropy for explanation and answer generation. In vision-language, multi-head architectures optimize an aggregate loss $$L_{\text{total}} = \alpha L_{\text{det}} + \beta L_{\text{lang}} + \gamma L_{\text{seg}}$$, reflecting detection, language, and segmentation objectives.

FPBench protocols report:

• Full data and low-resource (≤256 pairs) regime results
• Recall/precision on FPQs
• ROUGE-L/CLAIR for language output quality
• Exact match/F1 for normal QA accuracy (TPQs)

4. Empirical Results Across Modalities

Textual QA (FalseQA)

• MACAW-11B achieves 86.6% FPQ discrimination accuracy (Recall 86.0%, Precision 87.0%), and a rebuttal explanation ROUGE-L of ≈42.0 on full train. In low-shot (256-pair) settings, models ≥2.7B parameters reach 70–80% accuracy.
• In-context learning (GPT-3, 4-shot) yields ≈76% accuracy, ROUGE-L ≈38.
• Fine-tuning exclusively on FalseQA degrades general QA performance (ARC-DA F1: 54.5→22), which can be substantially mitigated by data replay (ARC-DA interleaving) (Hu et al., 2023).

Knowledge Graph (KG-FPQ)

• FPQ accuracy by confusability: lowest (Dis=0.693, Gen=0.500) for “neighbor & same concept” (NSC), highest for “non-neighbor & different relation” (NNDR, Dis=0.887, Gen=0.630).
• GPT-4 achieves 0.966 discriminative accuracy; best open-source model (Llama2-13B-Chat) 0.955/0.906 (Dis/Gen).
• Generative WH-form tasks are 10–20 percentage points more difficult than binary classification.

Multimodal

• SESAME (joint LMM) detects FP queries with 80–82% accuracy on FP-RefCOCO variants; CLAIR (correction quality) scores up to 0.67 (67% judged helpful); cIoU (segmentation under 50% FP queries) up to +31.7% relative gain over baselines (Wu et al., 2023).

Code Generation

• Best proactive error recognition rates (PRER): DeepSeek-R1 (0.48 / 0.59 / 0.64) for RUD, UPI, RAD respectively. Passive error detection (PAER) as high as 0.8 with explicit guidance.
• Self-scrutiny overhead ratios indicate that excess token generation (PAOR > 1.8) leads to negligible accuracy improvements but major redundancy. Each class of faulty premise activates distinct model failure pathways, revealing a triple dissociation in LLM behavior (Li et al., 5 Aug 2025).

5. Methodological Innovations

FPBench developments span several technical proposals:

• Multi-task and replay objectives: Avoid catastrophic forgetting of “normal” tasks by interleaving FPQ and standard QA/code/image batches, optimizing $$L = \sum_{\mathrm{FPQ}} (L_{\mathrm{disc}}+L_{\mathrm{gen}}) + \sum_{\mathrm{QA}} L_\mathrm{QA}$$.
• Gated, cascaded architectures: For vision-language, modular “see-say-segment” models decouple premise check, feedback, and downstream action, internally gating segmentation on prior negative detection.
• Hierarchical scrutiny modules: In code, layer static analysis (AST), premise-completeness inference, and logic-consistency checks.
• KG-driven large-scale automatic FPQ construction: Enables domain extension, fine-grained confusability, and adversarial red-teaming at scale.
• Evaluation leveraging purpose-trained judges (e.g., FPQ-Judge): LoRA-tuned LLMs automate hallucination detection in generative tasks, matching human assessment at ~93% accuracy.

6. Comparative Analysis, Open Challenges, and Future Directions

FPBench studies consistently observe:

• Generative, free-form refutation is harder for models than binary detection of FPQs, especially with semantically confusable premises.
• Larger parameter models and instruction-tuning (prompted explanation) improve FPQ resistance, but scaling alone is insufficient, especially in the presence of misleading contextual or structural corruptions.
• Automated, KG-based FPQ construction supports orders-of-magnitude larger and more diversified benchmarks than manual annotation, but requires domain calibration for real-world change and answer-bias mitigation.
• In multimodal settings, joint training with both positive and negative examples prevents catastrophic forgetting and hallucINATION under false premises.

Notable limitations remain, including premise extraction imperfections, non-trivial mutual exclusion/contradiction, coverage in cross-modal domains (beyond instance-level visual queries), and integration with external knowledge sources for open-world premise verification.

A plausible implication is that future FPBench extensions will emphasize compositional reasoning (multi-premise contradictions, temporal paradoxes), cross-modal verification (e.g., video, 3D environments), multi-round dialogue, and continual learning settings. Incorporation of premise-checking adapters in code assistants and fine-grained calibration in LLMs are recommended directions for operational reliability.

7. Summary Table: Representative FPBench Datasets

Benchmark	Modality	Scale	FPQ Types / Edits	Core Tasks
FalseQA	Text QA	2365 FPQs	8 error types, 6 formats	Detect FPQ, rebut, edit, answer
KG-FPQ	Text QA (KG)	178,320 FPQs	6 confusability edits, 3 domains	Binary/gen QA, hallucination
FP-RefCOCO(+/g)	Vision-Language	200k+ queries	Syn. replacements in references	Detect/explain FP, segment mask
Code FPBench	Code Generation	5400 cases	RUD, UPI, RAD	Detect FP, assess hallucination
QRPE	VQA	53,911 tuples	1st/2nd-order premise violation	Relevance, explanation

Collectively, these benchmarks facilitate rigorous, multidimensional evaluation of model robustness to FPQs, spanning detection, explanation, and avoidance of semantically invalid completions. By standardizing evaluation protocols, task structures, and data curation principles, FPBench provides a foundation for the next generation of reliable, premise-aware AI systems (Hu et al., 2023, Li et al., 5 Aug 2025, Wu et al., 2023, Zhu et al., 2024, Mahendru et al., 2017).