Pairwise Explanatory Verifier

• The paper demonstrates how pairwise comparative judgments enforce ranking and calibration constraints using methods like RCNN-based selection, reinforcement learning, and cascaded evidence strategies.
• Pairwise Explanatory Verifier is defined by simultaneously comparing two explanation targets, enabling precise post-hoc evaluation, dynamic test-time reasoning, and efficient candidate selection.
• Empirical findings reveal that pairwise approaches improve interpretability and accuracy while reducing computational cost across benchmarks in sentiment analysis, math reasoning, and coding tasks.

In recent arXiv usage, a pairwise explanatory verifier denotes a family of verifier constructions in which two explanation targets are judged jointly rather than independently. The targets may be feature-level explanation candidates for a single prediction, or two candidate solutions for the same reasoning problem. Across this literature, the pairwise operation serves different purposes: enforcing faithful ordering constraints in post-hoc explanation evaluation, producing calibrated comparative judgments with natural-language rationale, or allocating verifier compute through partial and full evidence views. The common structure is relational verification: the verifier does not ask only whether one object is good in isolation, but whether one object should outrank, outscore, or outsurvive another under explicitly defined explanatory criteria (Camburu et al., 2019, Garg et al., 24 Sep 2025, Lin et al., 15 May 2026).

1. Terminological scope and research settings

The phrase is not fully uniform across the cited literature. In one line of work, the verifier is an evaluation framework for post-hoc explainers under the feature-selection perspective. In another, it is a trained comparative judge for test-time reasoning that emits both rationale and calibrated confidence scores. In a third, it is an inference-only cascade that performs pairwise self-verification from structured partial evidence before escalating to full evidence (Camburu et al., 2019, Garg et al., 24 Sep 2025, Lin et al., 15 May 2026).

Work	Pairwise object	Explanatory content
"Can I Trust the Explainer? Verifying Post-hoc Explanatory Methods" (Camburu et al., 2019)	Relevant vs zero-contribution tokens	Ranking faithfulness under known constraints
"Calibrated Reasoning: An Explanatory Verifier for Dynamic and Efficient Problem-Solving" (Garg et al., 24 Sep 2025)	Two candidate responses	> rationale and calibrated scores
>	"CAPS: Cascaded Adaptive Pairwise Selection for Efficient Parallel Reasoning" (Lin et al., 15 May 2026)	Candidate solutions in a pool

A plausible implication is that pairwise explanatory verifier is best treated as an umbrella term for verifier designs with two defining commitments: comparative judgment and some explanatory intermediate representation. The explanatory representation, however, is domain-dependent. In post-hoc explainability it is a ranking over tokens; in RL-trained reasoning verification it is a natural-language rationale plus confidence vector; in cascaded selection it is a deliberately chosen evidence view that preserves discriminative cues while reducing verifier-token cost.

2. Pairwise verification in post-hoc explanation assessment

In "Can I Trust the Explainer? Verifying Post-hoc Explanatory Methods" (Camburu et al., 2019), the core object is not an explainer but a verification framework for post-hoc explainers under the feature-selection perspective. The paper first separates two explanation paradigms that are often conflated. Under feature-additivity, an explainer assigns contributions $w_i^x(f)$ such that

$\sum_i w_i^x(f) \approx f(x).$

Under feature-selection, the explanation is a subset $S(x)$ such that

$f(S(x)) \approx f(x).$

The paper argues that these answer different questions: feature-additivity asks what each feature’s average contribution is in a local neighborhood, whereas feature-selection asks which features were actually sufficient for the present instance. Direct comparisons across the two families can therefore be misleading.

The verifier is instantiated on an RCNN from Lei et al., with a generator and an encoder. The generator is a bidirectional recurrent network that outputs Bernoulli parameters for token selection, producing

$\mathcal{S}_x = \text{generator}(x),$

and the overall model is

$$\text{RCNN}(x) = \text{encoder}(\text{generator}(x)) = \text{encoder}(\mathcal{S}_x).$$

The model is trained jointly with only prediction supervision, with regularizers that encourage short, contiguous selections and fewer selected tokens, and because selection is discrete the training uses REINFORCE-style gradient estimation. The real-world task is BeerAdvocate multi-aspect sentiment regression on about 100K beer reviews with three aspects—appearance, aroma, and palate—and the prediction is a rating rescaled to $[0,1]$.

The crucial technical step is obtaining guarantees about which tokens matter. Hard selection alone does not ensure interpretability because the model may exploit a hidden communication protocol or handshake between selected and unselected tokens. To eliminate this possibility, the framework keeps only instances satisfying

$$\mathcal{S}_{\mathcal{S}_x} = \mathcal{S}_x \implies \text{ no handshake in } x.$$

The appendix formalizes the guarantee through

$$\text{RCNN}(\mathcal{S}_x) = \text{RCNN}(x) \implies \text{no handshake in } x,$$

and

$$\text{encoder}(\mathcal{S}_{\mathcal{S}_x}) = \text{encoder}(\mathcal{S}_x) \implies \text{no handshake in } x.$$

Retained instances therefore contain non-selected tokens with guaranteed zero contribution.

The framework then requires at least one selected token to be clearly relevant. For $\sum_i w_i^x(f) \approx f(x).$0, if

$\sum_i w_i^x(f) \approx f(x).$1

then $\sum_i w_i^x(f) \approx f(x).$2 is clearly relevant; the paper sets $\sum_i w_i^x(f) \approx f(x).$3 because the task uses ratings in increments of $\sum_i w_i^x(f) \approx f(x).$4. Each retained instance is partitioned into three sets: $\sum_i w_i^x(f) \approx f(x).$5 for non-selected zero-contribution tokens, $\sum_i w_i^x(f) \approx f(x).$6 for selected and clearly relevant tokens, and $\sum_i w_i^x(f) \approx f(x).$7 for selected tokens of unknown importance. Verification is then pairwise in the precise sense that an acceptable explainer should satisfy two necessary conditions: P1, every token in $\sum_i w_i^x(f) \approx f(x).$8 must be ranked below every token in $\sum_i w_i^x(f) \approx f(x).$9; and P2, the top-ranked token must be in $S(x)$0.

The paper defines three ranking metrics. Let $S(x)$1 be the explainer’s ranking of the tokens in instance $S(x)$2. Then

$S(x)$3

is the percentage of instances where the top-ranked token is non-selected;

$S(x)$4

is the percentage of instances with at least one misranking; and $S(x)$5 counts, on average, how many zero-contribution tokens are ranked above any clearly relevant token. The explainers tested are LIME, SHAP, and L2X. LIME and SHAP are feature-additivity methods, so the framework is not perfectly targeted at them; L2X is a feature-selection method, but it requires $S(x)$6, the number of important features, to be specified in advance.

The reported failure modes are strong. All explainers sometimes assign highest importance to a token guaranteed to have zero contribution. From Table 1, LIME reaches 14.79% on $S(x)$7 and L2X reaches 12.95%; SHAP also exhibits this failure, though generally less often. Misrankings are also substantial across aspects, often in the teens or twenties. The paper further reports that LIME and SHAP often outperform L2X on this feature-selection verification test, and attributes part of this to the practical difficulty of choosing $S(x)$8. In a palate example, LIME and SHAP rank tokens such as “mouthfeel” and “lacing” as most important even though they are non-selected zero-contribution tokens, while L2X also fails to surface the actually relevant token “gorgeous” near the top. This produces a clear prototype of a pairwise explanatory verifier: construct pairs of tokens with known relevance relation, then test whether the explainer orders them correctly.

3. Reinforcement-learned comparative verification with rationale and calibration

"Calibrated Reasoning: An Explanatory Verifier for Dynamic and Efficient Problem-Solving" (Garg et al., 24 Sep 2025) makes the term pairwise Explanatory Verifier explicit and applies it to test-time reasoning. The motivation is that advanced test-time strategies such as best-of-$S(x)$9, majority voting / self-consistency, and self-reflection / self-refine are limited by poor self-evaluation. The paper argues that reasoning models are often overconfident, biased toward their own responses, poor at detecting incorrectness, and especially weak when several sampled solutions look similar. A central failure mode is repeated identical wrong answers: on difficult questions the model may repeatedly generate the same incorrect answer, so majority voting provides no useful signal.

The verifier therefore compares two candidate responses jointly. Given a question $f(S(x)) \approx f(x).$0, two responses $f(S(x)) \approx f(x).$1, and correctness labels $f(S(x)) \approx f(x).$2, the policy $f(S(x)) \approx f(x).$3 generates a completion containing a rationale inside <think> tags and final ratings

$f(S(x)) \approx f(x).$4

for each response. The training objective is

$f(S(x)) \approx f(x).$5

The verifier is trained with Group Relative Policy Optimization (GRPO), and the ratings are intended to be calibrated confidence estimates rather than merely binary labels.

The reward design is central. For a raw score $f(S(x)) \approx f(x).$6, the paper first normalizes

$f(S(x)) \approx f(x).$7

and then clamps for stability via

$f(S(x)) \approx f(x).$8

This keeps $f(S(x)) \approx f(x).$9. The shaped reward is a sum of two binary cross-entropy-style terms:

$\mathcal{S}_x = \text{generator}(x),$0

The stated intent is to penalize confident mistakes strongly, encourage nuanced outputs, and avoid collapse to extreme ratings.

Training uses curated math and code data from Numina Math, CodeForces / TACO, and LeetCode. Multiple candidate solutions are generated using Qwen3-8B to obtain both correct and incorrect reasoning paths. The math verifier training set contains 3,634 unique input tuples $\mathcal{S}_x = \text{generator}(x),$1 from 628 distinct questions, with 294 tuples held out for validation. For code, correctness is determined by executing test cases in a sandbox. The procedure is strictly on-policy, with 1 gradient step per rollout group, learning rate $\mathcal{S}_x = \text{generator}(x),$2, 10 warmup steps, KL coefficient 0.001, and rollout sampling temperature 1.0 with top-$\mathcal{S}_x = \text{generator}(x),$3. Stage 1 trains on math-only data with maximum sequence length 8,192, 16 rollouts per prompt, global batch size 256, dynamic filtering that removes rollouts with no variance, and 240 steps. Stage 2 adds curated coding data plus a subset of math, increases maximum sequence length to 16,384, raises global batch size to 512, adds entropy coefficient 0.001, filters difficult problems using pass@$\mathcal{S}_x = \text{generator}(x),$4 difficulty $\mathcal{S}_x = \text{generator}(x),$5, and continues for 120 more steps. The paper reports training issues including truncated responses, entropy collapse, and ratings clustering near the midpoint.

The pairwise input is claimed to help because it allows the model to compare relative strengths, spot contradictions, detect which answer is less plausible, and identify when both answers are wrong. This matters precisely where majority voting fails. The calibration analysis shows that baseline Qwen3-8B tends to assign ratings near 10 regardless of correctness, whereas the RL-trained verifier spreads ratings across the whole range, separates correct from incorrect responses much better, and shows lower variance. Empirically, the verifier improves discernment across one-correct/one-incorrect, both-correct, and both-incorrect cases, with especially strong gains in identifying when both inputs are wrong.

As a retry mechanism in best-of-$\mathcal{S}_x = \text{generator}(x),$6, the verifier outperforms self-consistency at lower $\mathcal{S}_x = \text{generator}(x),$7 and is comparable at higher $\mathcal{S}_x = \text{generator}(x),$8 while using 1–3× fewer tokens. On AIME 2025, with Qwen3-32B generations, it reaches 0.77 accuracy while using only 75% of the tokens compared to self-consistency. For self-reflection, using verifier reasoning as feedback yields gains of up to 6 percentage points on AIME 2024 and 2025 compared to a simple consistency-check baseline, and also improves coding performance; example table values include Qwen3-8B on AIME 2025: 0.67 → 0.68, GPT-20B on AIME 2025: 0.65 → 0.71, and LCB v6: 0.39 → 0.44 for Qwen3-8B. The paper also reports that verifier-trained models do not degrade generation in single-shot pass@1: AIME 2024: 0.77 vs 0.78 and AIME 2025: 0.66 vs 0.68.

4. Cascaded adaptive pairwise selection and partial-evidence verification

"CAPS: Cascaded Adaptive Pairwise Selection for Efficient Parallel Reasoning" (Lin et al., 15 May 2026) studies pairwise self-verification as an aggregation primitive for parallel reasoning and argues that the main cost problem is that standard pairwise verification reads two complete solutions in full for each judgment. CAPS is an inference-only framework that adapts verifier compute along two orthogonal axes: an evidence axis, which controls how much of each candidate the judge sees, and a distribution axis, which controls how comparisons are spread across the candidate pool. The paper explicitly contrasts this with pointwise self-verification, which scores each candidate in isolation and is said to suffer from calibration failures, score saturation near the top, lack of a global scale, and self-preference bias. By contrast, standard pairwise self-verification such as V1-Infer fixes many calibration problems but still evaluates every comparison at full evidence.

The evidence axis has three levels. $\mathcal{S}_x = \text{generator}(x),$9 or $$\text{RCNN}(x) = \text{encoder}(\text{generator}(x)) = \text{encoder}(\mathcal{S}_x).$$0 is a discrete signature used only for clustering: for code it is a SHA-256 hash of normalized code, and for math it is the normalized boxed answer. $$\text{RCNN}(x) = \text{encoder}(\text{generator}(x)) = \text{encoder}(\mathcal{S}_x).$$1 or $$\text{RCNN}(x) = \text{encoder}(\text{generator}(x)) = \text{encoder}(\mathcal{S}_x).$$2 is partial evidence: for code, either the first $$\text{RCNN}(x) = \text{encoder}(\text{generator}(x)) = \text{encoder}(\mathcal{S}_x).$$3 lines or, in the implementation details, the first 50 plus last 50 reasoning words and the first 500 chars of code; for math, it is the boxed answer plus a short reasoning window. $$\text{RCNN}(x) = \text{encoder}(\text{generator}(x)) = \text{encoder}(\mathcal{S}_x).$$4 or $$\text{RCNN}(x) = \text{encoder}(\text{generator}(x)) = \text{encoder}(\mathcal{S}_x).$$5 is the full solution. The paper defines the evidence-cost ratio

$$\text{RCNN}(x) = \text{encoder}(\text{generator}(x)) = \text{encoder}(\mathcal{S}_x).$$6

and reports empirically that $$\text{RCNN}(x) = \text{encoder}(\text{generator}(x)) = \text{encoder}(\mathcal{S}_x).$$7 to $$\text{RCNN}(x) = \text{encoder}(\text{generator}(x)) = \text{encoder}(\mathcal{S}_x).$$8.

The distribution axis rests on the claim that the final $$\text{RCNN}(x) = \text{encoder}(\text{generator}(x)) = \text{encoder}(\mathcal{S}_x).$$9 depends mainly on ordering among the strongest candidates, so expensive comparisons should be concentrated on likely winners. CAPS therefore performs cheap elimination under partial evidence and reserves full-evidence comparisons for a small finalist set of size $[0,1]$0. It instantiates this in a four-stage cascade. Stage 0 clusters candidates by the $[0,1]$1 signature and keeps one representative per cluster; cluster size $[0,1]$2 is stored for tie-breaking but does not add to score, preserving “one-solution-one-vote” semantics. Stage A performs one halving round at $[0,1]$3 using slaughter pairing—strongest with weakest, second-strongest with second-weakest, with ordering seeded by cluster size $[0,1]$4. Stage B repeatedly halves the Stage A survivors at full evidence $[0,1]$5, now seeded by accumulated score $[0,1]$6, until only $[0,1]$7 finalists remain. In the default regime $[0,1]$8, Stage B is one full-evidence halving round. Stage C runs a complete round robin among the finalists at full evidence. The finalist score is

$[0,1]$9

and the output is $$\mathcal{S}_{\mathcal{S}_x} = \mathcal{S}_x \implies \text{ no handshake in } x.$$0.

The optional rescue subroutine CAPS-R addresses the principal Stage A failure mode: a good candidate can be eliminated under cheap evidence. It examines the strongest eliminated candidate $$\mathcal{S}_{\mathcal{S}_x} = \mathcal{S}_x \implies \text{ no handshake in } x.$$1 and the weakest finalist $$\mathcal{S}_{\mathcal{S}_x} = \mathcal{S}_x \implies \text{ no handshake in } x.$$2, restoring $$\mathcal{S}_{\mathcal{S}_x} = \mathcal{S}_x \implies \text{ no handshake in } x.$$3 if either

$$\mathcal{S}_{\mathcal{S}_x} = \mathcal{S}_x \implies \text{ no handshake in } x.$$4

with $$\mathcal{S}_{\mathcal{S}_x} = \mathcal{S}_x \implies \text{ no handshake in } x.$$5. These correspond to the margin condition and the rarity condition. The rescue adds at most one candidate, so its overhead is bounded by an additional $$\mathcal{S}_{\mathcal{S}_x} = \mathcal{S}_x \implies \text{ no handshake in } x.$$6.

The paper provides a closed-form verifier-token cost:

$$\mathcal{S}_{\mathcal{S}_x} = \mathcal{S}_x \implies \text{ no handshake in } x.$$7

with

$$\mathcal{S}_{\mathcal{S}_x} = \mathcal{S}_x \implies \text{ no handshake in } x.$$8

Its telescoped asymptotic form is given as

$$\mathcal{S}_{\mathcal{S}_x} = \mathcal{S}_x \implies \text{ no handshake in } x.$$9

with marginal-cost interpretation

$$\text{RCNN}(\mathcal{S}_x) = \text{RCNN}(x) \implies \text{no handshake in } x,$$0

For the standard setup $$\text{RCNN}(\mathcal{S}_x) = \text{RCNN}(x) \implies \text{no handshake in } x,$$1, $$\text{RCNN}(\mathcal{S}_x) = \text{RCNN}(x) \implies \text{no handshake in } x,$$2,

$$\text{RCNN}(\mathcal{S}_x) = \text{RCNN}(x) \implies \text{no handshake in } x,$$3

which, with empirical $$\text{RCNN}(\mathcal{S}_x) = \text{RCNN}(x) \implies \text{no handshake in } x,$$4, is about $$\text{RCNN}(\mathcal{S}_x) = \text{RCNN}(x) \implies \text{no handshake in } x,$$5, or roughly 11 full-evidence comparison equivalents per problem. With rescue,

$$\text{RCNN}(\mathcal{S}_x) = \text{RCNN}(x) \implies \text{no handshake in } x,$$6

and since $$\text{RCNN}(\mathcal{S}_x) = \text{RCNN}(x) \implies \text{no handshake in } x,$$7, the rescue adds less than 6% overhead on average.

Empirically, across 4 models and 5 benchmarks with $$\text{RCNN}(\mathcal{S}_x) = \text{RCNN}(x) \implies \text{no handshake in } x,$$8, CAPS compares Vanilla, Pointwise self-verification, V1-Infer, and CAPS. The headline averages are 37.7, 40.6, 46.5, and 48.2 Pass@1 respectively. CAPS beats V1-Infer on 14 of 20 suites and beats Pointwise on all 20. Representative gains include Qwen3-4B-Instruct on CodeContests: 7.9 → 14.5, Qwen3-14B on LCB-v5: 34.8 → 37.6, Qwen3-4B-Thinking on AIME: 53.3 → 56.7, and GPT-OSS-20B on AIME: 46.7 → 50.0; the six suites where V1-Infer is better are all regressions of at most 3.4 Pass@1 points. On code benchmarks, CAPS uses on average only 25.4% of V1-Infer’s verifier-token budget; on math, the average is 50.4%. The standard analytical ratio for $$\text{RCNN}(\mathcal{S}_x) = \text{RCNN}(x) \implies \text{no handshake in } x,$$9, $$\text{encoder}(\mathcal{S}_{\mathcal{S}_x}) = \text{encoder}(\mathcal{S}_x) \implies \text{no handshake in } x.$$0 is about 22–23% when $$\text{encoder}(\mathcal{S}_{\mathcal{S}_x}) = \text{encoder}(\mathcal{S}_x) \implies \text{no handshake in } x.$$1. The paper further reports that a random-pair baseline at the same comparison count performs close to or below Vanilla, indicating that performance depends on informative pair selection, not on pairwise judging alone.

A particularly important deployment result is the proposed diagnostic based on verifier per-pair accuracy under partial versus full evidence. The paper states that if CAPS’s mixed $$\text{encoder}(\mathcal{S}_{\mathcal{S}_x}) = \text{encoder}(\mathcal{S}_x) \implies \text{no handshake in } x.$$2 accuracy is comparable to or better than V1-Infer’s all-$$\text{encoder}(\mathcal{S}_{\mathcal{S}_x}) = \text{encoder}(\mathcal{S}_x) \implies \text{no handshake in } x.$$3 accuracy, CAPS tends to outperform V1-Infer in Pass@1. It gives a rough rule of thumb: when the difference is within about 5 points, CAPS usually dominates; when the drop exceeds about 5 points, the trade-off often reverses. This is presented as a concrete pre-deployment check.

5. Comparative structure: what is pairwise, what is explanatory, and what is being verified

The three formulations share a pairwise core but differ sharply in the object of verification. In the post-hoc explainability setting, the pairwise relation is between a known irrelevant token and a known clearly relevant token for the same instance. Verification succeeds if the explainer’s ranking respects the known order constraint. In the RL verifier for reasoning, the pairwise relation is between two complete candidate responses for the same question, and the output is not merely a winner but a pair of calibrated scores plus explanatory rationale. In CAPS, the pairwise relation again involves two candidate responses, but the explanatory content is shifted from rationale generation to structured partial evidence, which exposes salient answer-level or reasoning-level cues before full evidence is consulted (Camburu et al., 2019, Garg et al., 24 Sep 2025, Lin et al., 15 May 2026).

A common misconception is that all pairwise verifiers are interchangeable because they all compare two objects at once. The post-hoc explanation paper provides a direct warning against this broader error by showing that feature-additivity and feature-selection are fundamentally different explanation goals, so a method that is faithful under one criterion may appear incorrect under the other (Camburu et al., 2019). A plausible extension of that warning is that pairwise verification should always be read together with its target semantics: ranking faithfulness, comparative confidence calibration, or efficient survivor selection are not the same task.

The notion of “explanatory” is likewise non-uniform. In (Garg et al., 24 Sep 2025), it is explicit natural-language reasoning inside <think> tags. In (Lin et al., 15 May 2026), it is the use of partial evidence designed to preserve the information most relevant for discrimination, rather than full solutions. In (Camburu et al., 2019), the explanation is the explainer’s token ranking, and the verifier’s explanatory role is to establish whether that ranking respects ground-truth pairwise relevance constraints. This suggests that the explanatory component can be linguistic, evidential, or structural, provided that it mediates a faithful comparative judgment.

A second misconception is that pairwise verification necessarily implies full correctness certification. The explainability framework in (Camburu et al., 2019) is explicit that P1 and P2 are necessary conditions, not full correctness criteria. The RL verifier in (Garg et al., 24 Sep 2025) is designed to support dynamic control of test-time compute rather than formal proof of correctness. CAPS in (Lin et al., 15 May 2026) optimizes the cost-quality trade-off under a diagnostic condition on partial-evidence accuracy; it does not claim that partial evidence is universally sufficient.

6. Limitations, boundary conditions, and extension paths

The limitations differ by setting. In the post-hoc explanation verifier, the retained dataset gives guarantees only for the subset of instances satisfying the no-handshake condition and containing at least one clearly relevant token; the resulting verifier checks ranking constraints but does not require knowledge of the full ground-truth rationale (Camburu et al., 2019). The same paper nevertheless presents the framework as generic and states that the idea could be adapted to vision or other domains by using a model that hard-selects components such as super-pixels and then predicts from the selected subset.

In the RL-trained reasoning verifier, the stated limitations are that training is conducted on curated, largely verifiable domains such as math and code, depends on reliable automated correctness signals, is constrained by context length and data formatting, and focuses on a specific model family and benchmark suite (Garg et al., 24 Sep 2025). The future directions listed include richer natural-language feedback, co-designing generator-verifier systems, extending beyond math to broader coding or puzzle domains, improving reward functions for better calibration, incorporating consistency objectives so judgments are stable under answer order, and building more holistic agentic systems in which verification guides dynamic exploration.

For CAPS, the principal boundary condition is that efficiency gains depend on preserving discriminative signal under partial evidence. The paper reports that CAPS works best when verifier accuracy at $$\text{encoder}(\mathcal{S}_{\mathcal{S}_x}) = \text{encoder}(\mathcal{S}_x) \implies \text{no handshake in } x.$$4 is close to verifier accuracy at $$\text{encoder}(\mathcal{S}_{\mathcal{S}_x}) = \text{encoder}(\mathcal{S}_x) \implies \text{no handshake in } x.$$5; if partial evidence causes a large drop, CAPS can regress relative to full-evidence pairwise baselines (Lin et al., 15 May 2026). The paper proposes the partial-versus-full per-pair accuracy comparison as a pre-deployment check, and explicitly notes that if partial evidence is inadequate the model likely needs more context-aware partial extraction or full-evidence verification.

Taken together, these limits suggest that the central design problem for pairwise explanatory verification is not merely how to compare two objects, but how to do so under the right explanatory substrate. The verifier must have access to a representation whose omissions are controlled: zero-contribution tokens must truly be irrelevant, partial evidence must retain decisive signal, and natural-language rationales must be tied to calibrated confidence. Where those conditions hold, the cited work shows that pairwise explanatory verification can function as a rigorous ranking test, a dynamic routing mechanism for inference, or a computationally efficient selection pipeline.