acceptodds
Under review as a conference paper at ICLR 2027

Verifiable Robust Federated Inference of LLMs

11 views

Abstract

Organisations increasingly favour open-weight large language models (LLMs) because on-premise deployment avoids exposing proprietary assets and private data to third-party APIs. This choice trades one risk for another: open weights can be fine-tuned, quantised, or backdoored by anyone in the supply chain, and a single deployed model becomes a single point of failure whose faults are silent. Federated inference, which queries a diverse ensemble of models and aggregates their outputs, is a natural mitigation, but it only helps if aggregation itself tolerates a subset of faulty or adversarial models. In this work, we study Byzantine-robust federated inference of LLMs, and unlike prior work, we consider proper generation tasks, where the output space is not restricted to single tokens drawn from a small label set for classification tasks. Our key observation is that such tasks supply two resources classification lacks: a partial semantic-equivalence oracle over outputs, and an external verifier induced by executability or formal properties. We combine them in a unified framework based on plurality voting with abstention, which returns an answer only when its support exceeds a consensus threshold , and abstains otherwise. Our theoretical analysis bounds error and abstention for any instantiation of the framework in terms of the Byzantine coincidence rate, honest competence, equivalence oracle completeness, and verifier strength. The consensus threshold then controls the trade-off between error and coverage. We quantify how verifier strength buys plurality margin, and raise fault tolerance from to in ideal conditions. On HumanEval+, our method achieves 0.6% error at 89% coverage, versus 7.3% error for the best base model, and reaches zero error at higher . On MMLU, an adaptive adversary that endorses the largest incorrect cluster reduces accuracy by only 1%.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
collaborative inference, robust inference, LLMs

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_GYMuOpenReview ↗
Rating
1(−1)
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes Verified Plurality with Abstention (VPA), a Byzantine-robust federated-inference framework for LLMs that clusters outputs by a semantic-equivalence oracle, filters them with an external verifier, and returns the largest surviving cluster only if its support exceeds a threshold τ, with theoretical error bounds and strong results on HumanEval+ and MMLU.

Critical strengths

This paper focuses on federated inference of LLMs, a concrete scenario in large model applications, and proposes a solution to the security problems arising in this setting.

Critical weaknesses

Weakness 1: This method relies heavily on the verifier. However, if this verifier can be attacked (for example, through injected backdoors or latent bugs), the proposed method no longer holds.

Weakness 2: In addition, for natural language tasks beyond code, such as medical question answering, it is difficult to find such a verifier.

Weakness 3: The experimental coverage is too narrow. The evaluations on HumanEval+ and MMLU are not sufficient to adequately validate federated inference of LLMs.

Questions for authors

See weakness.

5 comments
AuthorsOpenReview ↗

Response to Reviewer GYMu

We thank the reviewer for their time and feedback. We appreciate the reviewer’s recognition that federated inference of LLMs is “a concrete scenario in large model applications” and that the paper proposes a solution to the security problems arising in this setting. We address the reviewer's concerns below:

  1. (W1) The method relies on the verifier; if it is attacked (backdoor, latent bugs), the method no longer holds: The guarantees do not require a perfect verifier and corollary 2.9 (1) extends to the case of no verifier. We also agree that verifier are hard to find for some subsets of tasks and our experiments cover some of those settings.

    • Imperfect verifiers are the default case. This is modelled by the false-accept and false-reject rates (α,β)(\alpha,\beta); all bounds degrade smoothly in them, and α=1\alpha=1 recovers the verifier-free guarantee (see, corollary 2.9-(1) in the paper). As such compromised verifier cannot cause errors below τ\tau. V\mathrm{V} only filters components, so a verifier can cause abstention (an availability failure) but cannot by itself produce a wrong answer. The verifier is what extends tolerance from τ\tau towards n−τn-\tau.
    • The verifier is not an LLM. It executes the candidate against tests (or runs CrossHair) inside the aggregator, so it has no weights in which a backdoor could be injected. Two attack surfaces remain, and we will make them explicit. (i) \emph{Test generation:} our tests are produced by an LLM, and a compromised generator can raise α\alpha or β\beta.

Please notice that V\mathrm{V} is not one of the federated models, and in our experiments the verifier is not an LLM. It is the aggregator's own test runner, inside the same trust boundary as the aggregator.

  1. W2. For natural-language tasks such as medical QA, a verifier is hard to find:

The framework covers this case explicitly: with no verifier (α=1\alpha=1, β=0\beta=0), \alg{} is plurality with abstention and Theorem 2.8 still applies. MMLU is this instantiation. Corollary 2.9(1) shows that without a verifier no aggregator can tolerate f≥n/2f\ge n/2 in the worst case, so this is a limit of the problem, not of VPA. Many deployed tasks do admit verifiers: code, SQL, structured or schema-constrained outputs, numerical computations, and formal proofs. Our medical task, MedCalc-Bench (Appendix 7), shows the verifier-free case in practice: no verifier is used (α=1\alpha=1, β=0\beta=0), the equivalence oracle is exact match or a 5%5\% tolerance, and VPA still matches the best base model on the tasks it answers at every τ\tau, with zero error for τ≥6\tau\ge6, without knowing which model is best. Medical calculations can also admit cheap verifiers (recomputing the score from extracted parameters, range and unit checks, etc.).

  1. W3. Experimental coverage (HumanEval+, MMLU) is too narrow.

The paper also evaluates MedCalc-Bench, a medical calculation benchmark (Appendix 7), in addition to HumanEval+ and MMLU, with 16 open-weight models from 11 developers (Table 2) and four equivalence oracles for code (CodeBLEU, Tests, RTests, CrossHair). We agree more is needed. We add EndoBench visual grounding task on 5 VLMs and extend MedCalc-Bench to cover the full test set. For ref see results from endobench in table bellow:

Table: [email protected] on EndoBench Visual Grounding: single models vs. VPA, accuracy with 95% bootstrap CIs.

[email protected] (%)No abstention: AllAbstain where VPA abstains: τ\tau=2τ\tau=3τ\tau=4
nemotron-3.5-super-vl43.9 [40.4, 47.7]48.5 [44.5, 52.5]53.6 [49.3, 58.2]64.5 [59.4, 69.7]
mimo-v2.543.3 [39.8, 47.1]47.1 [43.1, 51.1]51.8 [47.4, 56.1]59.2 [54.0, 64.5]
glm-4.6v42.8 [39.0, 46.3]46.9 [42.9, 50.7]51.0 [46.8, 55.1]61.0 [55.9, 66.3]
qwen3-vl-235b-a22b-instruct41.7 [38.0, 45.6]47.1 [43.1, 51.2]53.2 [48.9, 57.9]60.4 [55.3, 65.7]
deepseek-v4-flash-vision-exp34.2 [30.8, 38.0]38.5 [34.6, 42.4]44.4 [40.1, 48.5]52.3 [47.0, 57.6]
Best base model43.9 [40.4, 47.7]48.5 [44.5, 52.5]53.6 [49.3, 58.2]64.5 [59.4, 69.7]
VPA--51.7 [47.8, 55.7]56.5 [52.2, 60.9]64.5 [59.5, 69.6]
VPA − nemotron-3.5-super-vl--+3.3 [+0.7, +5.9]+2.8 [+0.2, +5.5]+0.0 [-2.1, +2.1]
Coverage (%)100.087.0 [84.5, 89.7]74.1 [71.0, 77.6]51.7 [47.8, 55.5]

Thank you for the clarifications and additional experiments. However, I still do not find sufficient experimental evidence for the claimed practical robustness. The mutant-attack evaluation is restricted to 140 tasks where correct honest answers already form a strict majority, while the CodeT attack comparison does not report the corresponding coverage. These limitations leave the robustness–availability trade-off insufficiently characterized.

Regarding W2, MedCalc-Bench evaluates structured numerical outputs for which exact matching or numerical tolerance is available. This does not fully address open-ended medical QA, where both correctness verification and semantic equivalence are difficult to establish. Reduction to plurality with abstention is a valid theoretical fallback, but does not itself demonstrate practical robustness in such settings. More extensive, more targeted adversarial evaluations are needed to substantiate the security claims.

Response to Reviewer GYMu

We than the reviewer for taking the time to respond.

  1. On the adaptive adversary please find bellow the results on full HumanEal+. (Note that restricting to tasks where majority is correct was done to match corollary 2.9-(1) result).

Adaptive attack impact on VPA the reported results are error vpa at a given f as (error(f) − error(f=0)) to see how the adaptive adversaries impacts error compared to when no attack is performed

Similarityτ\tau=2, ff=1τ\tau=2, ff=2τ\tau=2, ff=3τ\tau=3, ff=1τ\tau=3, ff=2τ\tau=3, ff=3τ\tau=6, ff=1τ\tau=6, ff=2τ\tau=6, ff=3τ\tau=7, ff=1τ\tau=7, ff=2τ\tau=7, ff=3
τ\tauCrossHair-0.4+3.9+6.3-0.4+0.3+6.5-0.2+0.8+1.7+2.5+3.4+5.4
τ\tauCodeBLEU+0.8+14.1+23.0+1.0+3.2+26.1+0.0+2.9+2.6+0.0+4.5+4.0
τ\tauRTests+0.6+1.2+1.8+0.6+1.8+2.4+2.1+3.5+4.7+0.7+2.3+3.8
τ\tauTests+0.0+1.4+2.5+0.0+2.5+3.6+1.4+4.2+4.8-0.1+3.1+3.8
τ\tau and VCrossHair+0.6+4.2+5.3+0.6+1.3+5.4+0.7+1.7+2.2+2.9+4.1+3.9
τ\tau and VCodeBLEU+0.9+11.0+18.4+1.1+2.3+20.5+0.0+3.1+2.9+0.0+4.8+4.2
τ\tau and VRTests+0.7+1.4+2.7+0.7+2.1+3.4+1.6+3.2+4.6+0.8+2.6+4.2
τ\tau and VTests+0.0+0.8+1.4+0.0+1.4+2.1+0.8+2.4+3.1-0.1+1.7+2.6
  1. We also report the coverage with the CodeT variant abstaining the same tasks as VPA to compare at matched coverage.

Table: VPA and CodeT (with and w/o abstention) under the Byzantine adaptive adversary

Error (%)No abstention: All tasksAbstain where VPA abstains: τ\tau=1τ\tau=2τ\tau=3τ\tau=6τ\tau=7
f=0
CodeT4.9 [1.8, 8.5]4.9 [1.5, 8.6]4.9 [1.5, 8.6]4.2 [1.4, 7.7]1.6 [0.0, 4.0]1.7 [0.0, 4.3]
VPA (RTests, τ\tau and V, abstain on ties)--4.9 [2.0, 8.6]4.2 [1.4, 7.7]3.5 [0.7, 6.7]0.8 [0.0, 2.4]1.7 [0.0, 4.3]
VPA − CodeT (same tasks)--+0.0 [-2.1, +2.1]-0.7 [-2.2, +0.0]-0.7 [-2.2, +0.0]-0.8 [-2.5, +0.0]+0.0 [+0.0, +0.0]
VPA − CodeT (no abstention)--+0.0 [-2.3, +2.2]-0.7 [-2.7, +0.7]-1.4 [-3.7, +0.4]-4.1 [-7.3, -1.2]-3.2 [-6.4, -0.6]
Coverage (%)100.087.287.286.678.772.6
Tasks answered164143143142129119
f=1
CodeT4.3 [1.8, 7.3]3.5 [0.7, 6.8]3.5 [0.7, 6.8]3.5 [0.7, 6.8]0.8 [0.0, 2.4]0.8 [0.0, 2.7]
VPA (RTests, τ\tau and V, abstain on ties)--3.5 [0.7, 6.8]3.5 [0.7, 6.8]3.5 [0.7, 6.8]0.8 [0.0, 2.4]0.8 [0.0, 2.7]
VPA − CodeT (same tasks)--+0.0 [+0.0, +0.0]+0.0 [+0.0, +0.0]+0.0 [+0.0, +0.0]+0.0 [+0.0, +0.0]+0.0 [+0.0, +0.0]
VPA − CodeT (no abstention)---0.7 [-2.7, +0.6]-0.7 [-2.7, +0.6]-0.7 [-2.7, +0.6]-3.5 [-6.7, -1.0]-3.4 [-6.7, -0.9]
Coverage (%)100.086.086.086.078.772.6
Tasks answered164141141141129119
f=2
CodeT7.3 [3.7, 11.6]4.4 [1.4, 8.0]4.4 [1.4, 8.0]4.4 [1.4, 8.0]0.8 [0.0, 2.5]0.8 [0.0, 2.7]
VPA (RTests, τ\tau and V, abstain on ties)--5.1 [1.5, 9.0]4.4 [1.4, 8.0]5.1 [1.5, 9.0]0.8 [0.0, 2.5]0.8 [0.0, 2.7]
VPA − CodeT (same tasks)--+0.7 [+0.0, +2.3]+0.0 [+0.0, +0.0]+0.7 [+0.0, +2.3]+0.0 [+0.0, +0.0]+0.0 [+0.0, +0.0]
VPA − CodeT (no abstention)---2.2 [-5.5, +0.8]-2.9 [-6.0, -0.3]-2.2 [-5.5, +0.8]-6.5 [-10.7, -2.9]-6.5 [-10.7, -2.9]
Coverage (%)100.083.583.583.577.472.6
Tasks answered164137137137127119

Making CodeT abstain in tasks VPA abstained in significantly reduces its error rates.

  1. On imperfect equivalene: We’d also like to highlight our Endo-Bench experiment (Sec. Appendix) where models generate bounding boxes. The equivalence is approximate. This directly tests our framework under approximate equivalence, beyond structured numerical outputs like MedCalc-Bench. Note also that even in code exact equivalence can't be established (Rice's theorem) so all the equivalence oracles we use are also approximate and are intentionally used to showcase how the equivalence impacts the results e.g., CodeBlue causing component fragmentation (reported in the paper).
Reviewer_sYX6OpenReview ↗
Rating
3
Confidence
3
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

This paper studies Byzantine-robust aggregation of multiple open-weight LLMs for generation tasks, where exact-output voting is not meaningful. It proposes Verified Plurality with Abstention (VPA), which clusters semantically equivalent outputs, filters clusters with a verifier, and answers only if verified support exceeds a threshold. The paper derives error and abstention bounds and evaluates VPA on code generation, MMLU, and medical calculation tasks.

Critical strengths

The paper identifies and formalizes a real gap between classification-style Byzantine aggregation and free-form LLM generation. Section 2 separates semantic agreement from correctness verification, and Algorithm 1 operationalizes this separation through clustering, verification, and abstention. This is consequential because it gives a coherent abstraction that covers code, numerical outputs, and label-based tasks rather than treating generation as ordinary voting over strings.

The analysis and empirical results show a meaningful reliability-coverage trade-off. Theorem 2.8 and Corollary 2.9 characterize error and abstention under explicit assumptions, while Table 1 shows that the RTests-based VPA variant reaches 0.7% error at 89.6% coverage on HumanEval+, compared with 7.3% error for the best base model evaluated without abstention. Figures 3–5 further demonstrate that higher consensus thresholds and abstention can prevent silent failures under the paper’s simulated attacks.

Critical weaknesses

The formal safety guarantee does not cover the practical VPA instantiations that drive the empirical claims. Theorem 2.8 relies on Assumption 2.6, namely a sound equivalence oracle such that an edge implies true semantic equivalence. Yet the main code oracles in Section 3.2, including agreement on LLM-generated tests and bounded CrossHair analysis, can declare inequivalent programs equivalent. The paper itself acknowledges this limitation in Section 4, but neither propagates the ϵ soundness error from Definition 2.1 through Theorem 2.8 nor empirically estimates such false merges. This matters because an erroneous edge can merge correct and malicious outputs into one connected component, invalidating the component-purity premise used in Lemma 6.1 and the subsequent verifier-error analysis. A resolution need not require a fully general new theorem: an extension with an explicit ϵ-dependent term, or a restricted guarantee for the concrete checkers supported by measured false-merge rates, would substantially strengthen the central claim.

The empirical Byzantine evaluation is too weakly aligned with the stated adaptive threat model. Section 3.1 says Byzantine models are simulated to “push abstention or flip the winning component,” while Figures 4, 5, and 7 focus on adversaries that support an existing incorrect or second-largest component. Such attacks establish vulnerability to vote inflation, but they do not test a Byzantine actor that knows the test-based clustering and verifier and deliberately submits distinct incorrect programs that agree on generated tests or seek verifier false accepts. Since the claimed practical contribution is robust federated inference under compromised models, this is the strongest plausible way the actual system could fail. Targeted checker-evasion attacks, even on a modest HumanEval+ subset, together with measured verifier false-accept rates under those attacks, are needed to support the practical robustness conclusion.

The claimed theoretical threshold trade-off is stated more strongly than what the bound proves. The paper claims in Section 2 that τ\tau controls a theoretical error-abstention trade-off and that increases in competence and verifier strength strictly reduce both quantities. The error bound in Equation 1 depends on τ\tau, but the abstention bound in Equation 2 is expressed through k0k_0 and once k0≥τk_0 \geq \tau it has no direct τ\tau dependence. Likewise, the abstention expression in Corollary 2.9 is independent of τ\tau. The empirical trend is clearly shown in Figures 3 and 6, but the theorem does not establish the claimed general monotonic trade-off. The authors should either narrow the language to empirical behavior under their settings or provide a τ\tau-dependent abstention characterization.

Questions for authors

In Section 3.2 and Table 1, are the tests used as the verifier distinct from HumanEval+ evaluation tests, including hidden tests used to compute the reported error? If any benchmark evaluation tests are used in the verifier, the reported error is not an independent estimate; if they are fully disjoint, clarifying this would substantially increase my confidence.

For the RTests-based HumanEval+ setting, how were the consensus thresholds and the acceptance criterion based on number of passed tests selected? Were these fixed before evaluating HumanEval+, or chosen after observing the benchmark’s error-coverage curve? A held-out calibration protocol would address concerns about threshold selection.

Can the authors report empirical estimates of false merges for each equivalence oracle, especially RTests, and false acceptance for the test-based verifier on adversarially selected incorrect programs? These quantities correspond directly to the unmodeled practical gap between Definition 2.1 and Assumption 2.6.

2 comments
AuthorsOpenReview ↗

**Response to Reviewer sYX6**

We thank the reviewer for the detailed and insightful review. We appreciate the reviewer’s assessment that the paper “identifies and formalizes a real gap between classification-style Byzantine aggregation and free-form LLM generation”, and that separating semantic agreement from correctness verification yields a coherent abstraction. We address each of the reviewer's concerns below:

  1. W1 / Q3. Theorem 2.8 assumes a sound oracle (Assumption 2.6), but test agreement and bounded CrossHair can falsely merge; propagate ϵ\epsilon or measure false merges. We do both:
  • Theory: Prop. 2.11 carries ϵ\epsilon through Theorem 2.8 by a coupling argument.

  • You are right that an erroneous edge can break component purity (Lemma 6.1). With an independent verifier, an impure component still produces an error only if V\mathrm{V} accepts a wrong representative, so in that case δE≤α⌊n/τ⌋\delta_{\mathcal{E}} \le \alpha\lfloor n/\tau\rfloor for any oracle. When the oracle and the verifier share tests, as in our submitted HumanEval+ configuration, only the verifier-free bound applies (see our reply to ow8V, W1). One condition: ϵ\epsilon must hold for adversarial pairs, which requires the oracle's randomness (its tests) to be hidden from the models.

    • For each oracle we report the false-merge rate on honest outputs, using disagreement on the HumanEval+ tests as the reference for non-equivalence (see Table bellow). This is a lower bound on ϵ\epsilon, since HumanEval+ is itself finite. The tolerance oracle used for decimal answers on MedCalc-Bench is likewise only approximately sound, as stated in Appendix~7.
False merges (%)Contaminated components (%)
CrossHair3.7 (146/3907)11.9 (25/210)
CodeBLEU2.4(40/1655)2.7 (6/220)
RTests2.4 (142/5971)9.4 (17/180)
Tests2.4 (144/5933)8.8 (16/182)
  1. The adversaries only support existing components; test a checker-aware adversary that submits distinct wrong programs agreeing on the generated tests or seeking false accepts. We add the experiment to the updated paper's appendix and report the result and the mutant strategy (also refer to response to reviewer ow8V).

  2. W3. The claimed τ\tau trade-off is stronger than what the bounds prove: Eq.(2) has no direct τ\tau dependence once k0≥τk_0\ge\tau, and Corollary 2.9's abstention term is independent of τ\tau: Thank you for pointing this out, we agree that Theorem 2.8, as stated, does not establish the trade-off. \theo{Prop.~2.13 (R3)} now proves it:

    • The quantities themselves. For every realisation, if \alg{} answers at threshold τ+1\tau+1 it gives the same answer at τ\tau. Hence δE\delta_{\mathcal{E}} is non-increasing and δ⊥\delta_\perp non-decreasing in τ\tau, exactly, not only in the bounds.
    • Explicit τ\tau-dependent bound. Taking k0=τk_0=\tau in the proof of Theorem 2.8 gives δ⊥≤P[Bin(h,p)≤τ−1]+Φ(τ)+β+α Eτ(t′)\delta_\perp \le \mathbb{P}[\mathrm{Bin}(h,p)\le\tau-1] + \Phi(\tau) + \beta + \alpha\,\mathcal{E}_\tau(t'), whose honest-mass term increases with τ\tau.

Corollary 2.9 is independent of τ\tau by design: with p=1p=1 and c=1c=1 the honest class always has size h≥τh\ge\tau, so abstention can only come from the verifier. We will also replace `strictly reduce with the bounds are non-increasing in pp, α\alpha and β\beta''.

  1. Are the verifier's tests disjoint from the HumanEval+ evaluation tests?

The test generator receives only the task prompt (signature and docstring) and never sees the HumanEval or HumanEval+ test suites, which are used only to score the final output. All the errors are reported on the humaneval+ tests after electing a candidate response using our generated tests and equivalence oracles.

  1. How were τ\tau and the acceptance criterion selected? In our experiments we did not pre-select τ\tau: Table~1 and Figures 3--6 report the full sweep. The theory suggest under reliable strong verifiers τ\tau can be set to be small to avoid unecessary abstentions. Under unreliable or no verifier, per corollary 2.9 τ\tau then is the only safety knob left and τ>f\tau>f is set depending on the expected number of Byzantine.

  2. False accept rates and false reject rates under teh adaptive adversary for VPA with Rtests. Results for under all equivalence oracles can be founded in teh appendix of the updated paper:

Table: False Accept Rate (FAR) and False Reject Rate (FRR) of the verifier under varying equivalence oracles under the adaptive adversary on V

SimilarityRulefτ=2 FARτ=2 FRRτ=3 FARτ=3 FRRτ=6 FARτ=6 FRRτ=7 FARτ=7 FRR
RTestsτ and V00.012.90.012.90.016.40.030.7
RTestsτ and V15.912.97.112.98.315.78.323.6
RTestsτ and V24.712.113.312.116.715.716.723.6
RTestsτ and V36.011.47.111.423.115.023.122.1

We thank the reviewer for their positive comments and appreciate their feedback. We hope our responses address all the raised concerns.

Reviewer_ow8VOpenReview ↗
Rating
3
Confidence
3
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

A major challenge in federated inference is some of the participating models can be compromised. This paper introduces a new method VPA for federated inference where the input prompt is sent to multiple open source LLMs and the generated outputs are combined so that the final response is correct even if some llms are harmed. For tasks like classification the problem can be sloved by ensemble voting but in case of code the generated output can rarely be identical. Therefore, voting does not work in this case. To solve it, this method uses two components, (i) an equivalence oracle that checks if two outputs mean the same thing e.g., two programs behaving the same on a set of tests and (ii) a verifier that checks if a single output is correct on its own e.g., passing a formal check. The outputs are then grouped using the oracle, groups rejected by the verifier are dropped and the largest remaining group is returned if it is big enough, otherwise the method abstains.

The method is evaluated on code generation datasets like Humaneval+ (python code completion), multiple choice and medical calculation tasks with open weight models, including a simulated adversary, and is compared against the best single model and CodeT. The results that proposed framework achieve lower error than any single model at the cost of abstaining on some of the problems.

One of the major contributions is a theorem that bounds the error and abstention rate and show that with a verifier the method can tolerate more than half of the models being faulty.

Critical strengths
  • The proposed method is a sensible design for generation tasks as it uses equivalence oracle to group the outputs and uses a subsequent verifie to check them.
  • Suggested Abstenation is also pretty useful as an adversary that controls fewer models than the threshold can at most make the method abstain and therefore, cannot make it return a compromised answer. The authors also show that the suggested verifier method still works when more than half of the models are compromised which is not possible by using ensemble approaches like majority voting.
  • The experiments are done with (i) real open weight models from different providers, (ii) three different ways of building the equivalence oracle including symbolic execution with CrossHair and (iii) three different task types.
Critical weaknesses
  • One of my major concerns is that the Assumption 2.7 requires the verifier to be independent of the equivalence oracle, but in the main code setup the oracle groups programs based on how they behave on LLM generated tests. Moreover, the verifier is the number of those same tests a program passes. So a wrong program that passes the generated tests ends up in the correct group and also gets accepted by the verifier.
  • Another major issue is that the adversary never attacks the verifier as the simulated adversaries only copy or support outputs that other models have already produced.
  • The performance gains over the single best model are small as at full coverage the difference to the best single model is a handful of problems and there are no reported confidence intervals.
Questions for authors
  • Can you rerun the code experiments with a verifier that is independent of the equivalence oracle, e.g., tests generated by a different model or a held out split of the generated tests? This would help us to see if Assumption 2.7 holds.
  • Can you add an adversary that returns a new wrong program which passes all the visible tests, e.g., a mutant of a correct solution that only fails the hidden HumanEval+ tests? This is the case described in your threat model and the one where the verifier should matter.
  • Also, can you also please report confidence intervals for Table 1 and give CodeT an abstention option so the comparison with VPA is at the same coverage.
3 comments
AuthorsOpenReview ↗

Response to Reviewer ow8V

We thank the reviewer for a careful and constructive review. We are glad the reviewer found the design sensible for generation tasks, and in particular recognised the role of abstention and verifier when available. We address each of the reviewer's concerns below.

  1. (W1 / Q1. Assumption 2.7 requires VV independent of EE): We agree: in the RTests configuration of Table1 the assumption does not hold. We rerun HumanEval+ experiments and update all the results using a verifier with new generated tests using a different model (Mimo-v2.5Pro). Assumption 2.7 then holds conditionally on the task, since neither test set is shown to the models. Figure9 (Appendix 7) already reports CrossHair as E\mathrm{E} with the test-based VV, a configuration that is independent by construction, and we will move it to the main text.

  2. {W2 / Q2. The adversary never attacks the verifier: can you add a wrong program that passes all visible tests, e.g.\ a mutant that only fails the hidden HumanEval+ tests?}

Thank you for this suggestion to stress test the approach; we add it as Figure 8 in the Appendix of the revised paper. The Byzantine models submit mutants of a correct solution that fail at least one HumanEval+ test. We consider an adversary that knows a subset of the aggregator's tests (as a worst case as in our setting/threat model the tests are generated by the aggregator at aggergation-time and never revealed). For f∈{0,1,2,3}f \in \{0, 1,2,3\} Byzantine models submit the same mutant of the correct that passes the test subset, attacking V\mathrm{V} through α\alpha and colluding to reach τ\tau. The theory states what to expect: against a test-aware adversary, test-based checks have α=1\alpha=1 and no guarantee survives unless the correct models are a majority. With an oracle that can refute mutants, such as CrossHair, still gives integrity for f<τf<\tau even with α=1\alpha=1. Find bellow a table summarizing the attack impact under all equivalence oracle with and w/o verifier:

Equivalenceτ\tau=2, f=1τ\tau=2, f=2τ\tau=2, f=3τ\tau=3, f=1τ\tau=3, f=2τ\tau=3, f=3τ\tau=6, f=1τ\tau=6, f=2τ\tau=6, f=3τ\tau=7, f=1τ\tau=7, f=2τ\tau=7, f=3
τ\tauCrossHair-0.1+3.7+6.1-0.1+0.7+6.2+0.7+1.8+1.5-0.2+1.0+3.3
τ\tauCodeBLEU+1.0+11.3+20.2+1.2+3.5+21.6+0.0+2.9+2.6+0.0+4.5+4.0
τ\tauRTests+0.7+1.4+2.1+0.7+1.4+2.1+0.8+1.5+2.2+0.9+1.7+2.5
τ\tauTests+0.0+2.2+2.2+0.0+2.2+2.2+0.0+2.3+2.3+0.0+2.6+2.5
τ\tau and VCrossHair+0.9+4.4+6.2+0.9+1.9+6.4+1.3+2.5+2.3+1.5+2.9+2.7
τ\tau and VCodeBLEU+1.1+8.3+16.1+1.3+2.6+17.6+0.0+3.1+2.9+0.0+4.8+4.2
τ\tau and VRTests+0.8+1.6+2.4+0.8+1.6+2.4+0.8+1.7+2.5+0.9+1.9+2.8
τ\tau and VTests+0.0+0.8+0.8+0.0+0.8+0.8+0.0+0.9+0.9+0.0+1.0+0.9

With test-based similarity (RTests and Tests), in the worst case (f=3f = 3, with the verifier) the number of incorrect answers is 3 tasks for every τ\tau while the number of answered tasks falls from 124 at τ=2\tau = 2 to 109 at τ=7\tau = 7, so the error moves from 2.4% to 2.8%. The increase therefore reflects a shrinking denominator, not additional failures. With CodeBLEU and CrossHair similarity the usual trend holds: the mutants are not merged with the correct programs and form small groups of their own, which a larger τ\tau filters out.

  1. W3 / Q3. Gains over the best single model are small; no confidence intervals; give CodeT an abstention option. We agree that the differences are a handful of tasks. Two clarifications:
    1. The best single model is identified in hindsight. A deployment does not know which model it is, nor whether it is the compromised one. Averaged over the 11 models, single-model error at full coverage is 19.3%19.3\% (median 16.5%16.5\%). Please notice that our paper's claim is robustness: any single model tolerates f=0f=0.
    2. We add paired bootstrap 95% intervals (10410^4 resamples over tasks) for every entry of Table~1 and to the additional experiments on MedCalc Bench and EndoBench.
    3. We implemented a multi-model version of CodeT as an instantiation of the VPA framework, where test-agreement is used as the equivalence oracle, tests passed as the verifier, the product as aggregation, and τ=1\tau = 1 as treshold. Note that the original CodeT uses the same model for generating code and tests and does not have a defined notion of abstention.

We also report the coverage with the CodeT variant abstaining the same tasks as VPA to compare at matched coverage.

Table: VPA and CodeT (with and w/o abstention) under the Byzantine adaptive adversary

Error (%)No abstention: All tasksAbstain where VPA abstains: τ\tau=1τ\tau=2τ\tau=3τ\tau=6τ\tau=7
f=0
CodeT4.9 [1.8, 8.5]4.9 [1.5, 8.6]4.9 [1.5, 8.6]4.2 [1.4, 7.7]1.6 [0.0, 4.0]1.7 [0.0, 4.3]
VPA (RTests, τ\tau and V, abstain on ties)--4.9 [2.0, 8.6]4.2 [1.4, 7.7]3.5 [0.7, 6.7]0.8 [0.0, 2.4]1.7 [0.0, 4.3]
VPA − CodeT (same tasks)--+0.0 [-2.1, +2.1]-0.7 [-2.2, +0.0]-0.7 [-2.2, +0.0]-0.8 [-2.5, +0.0]+0.0 [+0.0, +0.0]
VPA − CodeT (no abstention)--+0.0 [-2.3, +2.2]-0.7 [-2.7, +0.7]-1.4 [-3.7, +0.4]-4.1 [-7.3, -1.2]-3.2 [-6.4, -0.6]
Coverage (%)100.087.287.286.678.772.6
Tasks answered164143143142129119
f=1
CodeT4.3 [1.8, 7.3]3.5 [0.7, 6.8]3.5 [0.7, 6.8]3.5 [0.7, 6.8]0.8 [0.0, 2.4]0.8 [0.0, 2.7]
VPA (RTests, τ\tau and V, abstain on ties)--3.5 [0.7, 6.8]3.5 [0.7, 6.8]3.5 [0.7, 6.8]0.8 [0.0, 2.4]0.8 [0.0, 2.7]
VPA − CodeT (same tasks)--+0.0 [+0.0, +0.0]+0.0 [+0.0, +0.0]+0.0 [+0.0, +0.0]+0.0 [+0.0, +0.0]+0.0 [+0.0, +0.0]
VPA − CodeT (no abstention)---0.7 [-2.7, +0.6]-0.7 [-2.7, +0.6]-0.7 [-2.7, +0.6]-3.5 [-6.7, -1.0]-3.4 [-6.7, -0.9]
Coverage (%)100.086.086.086.078.772.6
Tasks answered164141141141129119
f=2
CodeT7.3 [3.7, 11.6]4.4 [1.4, 8.0]4.4 [1.4, 8.0]4.4 [1.4, 8.0]0.8 [0.0, 2.5]0.8 [0.0, 2.7]
VPA (RTests, τ\tau and V, abstain on ties)--5.1 [1.5, 9.0]4.4 [1.4, 8.0]5.1 [1.5, 9.0]0.8 [0.0, 2.5]0.8 [0.0, 2.7]
VPA − CodeT (same tasks)--+0.7 [+0.0, +2.3]+0.0 [+0.0, +0.0]+0.7 [+0.0, +2.3]+0.0 [+0.0, +0.0]+0.0 [+0.0, +0.0]
VPA − CodeT (no abstention)---2.2 [-5.5, +0.8]-2.9 [-6.0, -0.3]-2.2 [-5.5, +0.8]-6.5 [-10.7, -2.9]-6.5 [-10.7, -2.9]
Coverage (%)100.083.583.583.577.472.6
Tasks answered164137137137127119

Making CodeT abstain in tasks VPA skipped significantly reduces error rates.

We thank the reviewer for their positive comments and appreciate their feedback. We hope our responses address all the raised concerns.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Response

We thank the reviewers for their detailed feedback. ow8V and sYX6 converge on two points: (i) the guarantees assume a sound equivalence oracle E\mathrm{E} and a verifier V\mathrm{V} independent of E\mathrm{E} (ii) the simulated adversaries never target E\mathrm{E} or V\mathrm{V}. We address both with new results and new experiments.

New theory: added in the \textbf{revised PDF }(changes in blue; Section 2.3, proofs in Appendix 6.3). Each proof reuses only lemmas already in the paper:

  1. Unsound oracles(Prop. 2.11) extends soundness error ϵ\epsilon (Definition 2.1)

  2. Exact trade-off in τ\tau (Prop. 2.13). For every realisation, raising τ\tau can only turn an answer into an abstention. Hence error is non-increasing and abstention non-decreasing in τ\tau. We also give an explicit τ\tau-dependent abstention bound.

New experiments

  1. We re-run the experiments with a verifier using generated tests different from both Tests and Rtests, thus decoupling the equivalence oracle E\mathrm{E} from the verifier V\mathrm{V}.

  2. We add an adaptive worst case adversary that attacks V\mathrm{V} with mutants that pass the generated tests but fail HumanEval+.

  3. We measure and report the false merge rate of the equivalence oracles.

  4. All tables are updated with confidence intervals.

  5. We extend MedCalc bench results to the full test set and we also add results on an additional benchmark for visual grounding.

Overall edits to the paper

  1. Soundness is relaxed in Proposition 2.11 and false merges of all equivalance oracles are reported in the paper (Table 3 in the appendix and see result bellow)
  2. Table1 is updated with confidence intervalls and is run with the new verifier tests generated by a seperate model different from those used for equivalence.
  3. Fig 8 presents the results under the adaptive attacker with access to verifier tests. We summarize the results in table (see bellow)
  4. Additional results adding EndoBench vizual grounding task and extending MedCalc bench to the full tests set. All results are reported, respectively, in and Table.5 and Table.6 in the Appendix with confidence intervalls.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.