acceptodds
Under review as a conference paper at ICLR 2027

DARC: Denoised Authorized Reparameterized Coding for LLM Unlearning via First-Order Noise Cancellation

Abstract

LLM unlearning faces a disclosure conflict when a server keeps its model parameters confidential and a client withholds raw forget data from that server. Noisy model publication can limit disclosure, but it also changes the unlearning update. We propose DARC (Denoised Authorized Reparameterized Coding), coupling model publication with authorized update recovery through executors granted temporary access to client data. The server releases model copies using correlated Gaussian perturbations and function-preserving coordinate transformations, under an isolation assumption limiting each coalition to same-round copies. After aligning all returned updates, inverse-scale aggregation cancels the common first-order perturbation response of a shared locally smooth update map. We prove the decoder's uniqueness among normalized linear rules with universal first-order cancellation and analyze curvature, optimizer, and stochastic errors. Under a fixed public positive-definite noise covariance and independent key/code sampling, we derive exact neighboring-checkpoint R\'enyi divergence for key-revealed views and extend checkpoint-privacy bounds to complete executor transcripts under the stated auxiliary-release conditions. Our optimizer analysis identifies exact-arithmetic Adam-family compatibility conditions and quantifies discrepancies from continuous attention rotations. Experiments on Llama and Qwen series models with TOFU and MUSE benchmarks assess forgetting, retained utility, and update fidelity. For Llama-1B on TOFU, the six non-collapsed trainers have utility scores within of their noise-free references. Targeted diagnostics reveal numerical compatibility gaps and closely matching outputs from individual published views on the tested prompts. DARC connects bounded checkpoint disclosure with optimizer-aware approximation of a chosen unlearning method's noise-free update.

Primary area:
other topics in machine learning (i.e., none of the above)
Keywords:
Machine Unlearning, Noise Cancellation

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_iUzBOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper studies collaborative LLM unlearning when model parameters and forget data are held by different parties. The authors propose DARC, which publishes multiple model views using correlated Gaussian noise and function-preserving reparameterizations. Authorized executors perform local unlearning, while the server aggregates their updates using inverse-scale weights to cancel the common first-order noise effect. The paper provides analyses of checkpoint privacy under bounded collusion, update recovery errors, and optimizer compatibility. Experiments on Llama and Qwen models with TOFU and MUSE evaluate forgetting performance, retained utility, and update fidelity.

Critical strengths
  1. The paper addresses a meaningful problem by combining checkpoint protection with authorized unlearning. Theorems 1 and 2 analyze checkpoint privacy under bounded collusion and first-order noise cancellation, respectively, with clearly stated assumptions. This provides a useful framework for collaborative unlearning.
  2. The analysis of optimizer compatibility is technically valuable. Theorem 3 distinguishes the effects of signed permutations and continuous rotations on Adam-family optimizers. The experiments cover multiple unlearning methods, models, and datasets, and also report numerical discrepancies between theoretical compatibility and practical implementations.
Critical weaknesses
  1. The methodological novelty appears somewhat limited. Correlated noise cancellation, privacy-preserving collaborative learning, and parameter symmetries have been studied in prior work, including DECOR, Offsite-Tuning, and privacy-preserving federated unlearning. Although DARC adapts these ideas to LLM unlearning and provides a first-order error analysis, its distinct contribution over existing techniques is not sufficiently established. Moreover, the comparisons in Table 2 differ in computation and perturbation settings, while Figure 3 shows that the aggregated update error (0.3890) is slightly higher than that of one individual view (0.3726). This makes the practical benefit of the proposed mechanism unclear.
  2. The practical model confidentiality remains questionable. Theorem 1 requires a fixed public covariance, complete release accounting, and a specified sensitivity bound, while some experimental settings do not satisfy the conditions for full-checkpoint privacy accounting. In Appendix J.9, Table 62 shows that public-anchor alignment using only one published view achieves a relative parameter error of approximately (6.44\times10^{-5}). Table 64 also reports highly similar outputs between individual views and the original model. These results do not invalidate the conditional RDP theorem, but they raise concerns about the practical confidentiality provided by DARC.
Questions for authors
  1. Compared with existing correlated noise cancellation and privacy-preserving collaborative learning methods, such as DECOR, what is the main distinct technical contribution of DARC? Could the authors clarify which challenges cannot be directly addressed by existing approaches?
  2. Appendix J.9 shows highly accurate parameter recovery from a single published view using a public base model. How do the authors reconcile this observation with the practical model confidentiality objective? Can a meaningful privacy budget be provided for the evaluated noise settings?
  3. Could the authors provide more closely matched comparisons in terms of computation and perturbation settings to demonstrate the benefit of inverse-scale aggregation over simpler single-view or multi-view averaging strategies? Also, Eq. (5) and Algorithm 1 use different orders of noise addition and parameter transformation. Please clarify which formulation is implemented.
6 comments
AuthorsOpenReview ↗

Response to Reviewer iUzB (1/2): W1 / Q1 and Q3

Your review asks what DARC contributes beyond existing noise-cancellation methods and whether its benefit and confidentiality hold in practice. We answer with a comparison matched in compute and noise against independent-noise averaging (Tables 71–73), an explicit budget in a configuration that meets Theorem 1's conditions (Tables 68, 70; part 2/2), and a clarification of Algorithm 1. Table numbers refer to the revised PDF; the tables are also in the general response.

W1 / Q1. The contribution over DECOR, Offsite-Tuning and privacy-preserving federated unlearning is not established. Which challenges can existing approaches not address?

DARC's distinct element is correlated noise that passes through a nonlinear multi-step optimizer before it is combined, used to protect the model owner's parameters. Section 2 now states the difference from DECOR.

  1. DECOR. Users add pairwise-canceling Gaussian noise to the models they exchange in decentralized SGD, to protect their data from peers. The noise enters a linear average, where the correlated terms cancel. In DARC each noise term passes through K steps of Adam on a different executor before aggregation, so linear cancellation does not apply. Theorem 2 (first-order cancellation with a curvature residual), Proposition 1 (the decoder weights) and Theorem 3 (which keys keep Adam trajectories aligned) address this case.
  2. Direction of protection. DECOR and privacy-preserving federated unlearning protect data holders, and the model is shared in the clear. DARC protects the model holder's parameters from the data side. Theorem 1's exact coalition accounting is for that direction.
  3. Offsite-Tuning. It sends a lossy emulator and trains adapters, so the update is adapter-only and is computed on a different model. DARC keeps the chosen full-model trainer, returns its full-model update, and measures the deviation from the noise-free update (Tables 71, 73).
  4. Evidence that the code matters beyond averaging (four of six methods). An average of independent-noise views has the same compute and the same per-executor noise as DARC. In Tables 71 and 72 it is formed from the same trained copies, paired across noise seeds instead of within a zero-sum group, so the comparison isolates the code. DARC's mean error is lower in all 72 cells of Tables 71 and 72: by 8–48% for NPO, SimNPO, UnDIAL and SatImp, and by 1–6% for GradDiff and GradAscent. Seed by seed (m = 2, submitted configuration), it is lower in 207 of 216 comparisons for the first four methods and in 71 of 108 for the other two. Under the benchmark protocol it is lower in 25 of 27 paired runs for NPO, SimNPO and UnDIAL and in 4 of 9 for GradDiff (Table 73). For GradDiff and GradAscent the code is therefore on par with independent averaging.

Q3 (and W1, second part). Please match computation and perturbation in the comparisons; Figure 3; which of Eq. (5) and Algorithm 1 is implemented?

(a) Matched comparisons. We added them in Tables 71–73. Table 2 did not match computation and perturbation; Section 6.2 of the submission notes that its one-copy control differs in both. The new tables compare a single view, an average of independent-noise views and DARC with the same client loop, batches, seeds, key family and marginal noise. The last two have equal compute. Against the independent average, DARC's mean error is lower in all 72 cells (item 4 above). Against the single view, DARC is closer in 36 of 36 paired runs of Table 73, with 0.25–0.80 of its error. In Table 71, independent averaging leaves 0.72–0.83 of a single view's error for NPO, SimNPO, UnDIAL and SatImp, and DARC leaves 0.37–0.74. Every arm stays within 0.014 MU of the noise-free run, so scalar metrics do not separate the estimators at these noise levels, and the revision bases the denoising claim on update fidelity.

(b) Figure 3 (0.3890 against 0.3726). The figure is a single GradDiff noise draw with three copies, and its best copy can only be identified with the clean reference. Over nine new draws with three equal-scale copies at κ = 0.01, the mean errors are 0.38 (one view, sd 0.18), 0.29 (independent average of three) and 0.28 (DARC) (Table 72). GradDiff is the objective where the code adds least. Section 6.4 now describes Figure 3 as a single draw and reports these results; more detail is in our response to Reviewer DXjc (W2, item 5).

(c) Order of noise and key. The implementation follows Eq. (5): noise is added in canonical coordinates and the key is applied afterwards, θ_pub = T(θ + αe). We apologise that algorithm 1 in original version did not make this clear: its first line cited Section 4.2 for both the noise and the keys. For revised version, it now cites Section 4.1 for the noise, and its line 3 sends T(θ + αe), as in Eq. (5). The order matters for the zero-sum constraint, which is defined in canonical coordinates.

AuthorsOpenReview ↗

Response to Reviewer iUzB (2/2): W2 / Q2

W2 / Q2. Practical confidentiality is questionable: some settings do not meet Theorem 1's conditions, one view allows accurate parameter recovery (Table 62) and has near-identical outputs (Table 64). Can a meaningful budget be given?

A budget is now given, together with a new configuration that meets all conditions of Theorem 1 (Tables 68, 70). We agree with your concern with Tables 62 and 64: at κ = 0.01 one view determines the parameters up to the injected noise, and its outputs match the original model's. The submission reports both (abstract; Appendix B.6, J.9), but its main text did not say that DARC bounds what a coalition learns about the parameters and does not hide the function. Section 3 now does.

  1. Budget. At κ = 0.01 and m = 2, one view is (1, 10⁻⁵)-DP within Δ = 0.0027 whitened units (Table 68). This is a statement of Theorem 1 in the formal configuration; for the submitted runs it holds only in the restricted sense of item 3. In the same units the fine-tuning delta has norm 482 (formal) or 3.1 × 10⁴ (submitted), and the model retrained without the forget set is 139 or 1.6 × 10⁴ away, so at this κ the radius covers only small parameter differences; Section 5.1 now says so. Theorem 1 is a metric-privacy statement about parameters, and the submission does not claim a record-level bound (Section 3 notes that one would need a separate sensitivity certificate).
  2. Table 62. Public-anchor alignment removes the key, and Theorem 1 is proved with keys revealed. The remaining error, 6.44 × 10⁻⁵ of ‖θ‖, is the injected noise: we measure a noise norm of 0.0446 against ‖θ‖ = 706.6, a ratio of 6.3 × 10⁻⁵. The parameter protection at this κ is the radius of item 1, and it grows linearly with κ.
  3. Conditions of Theorem 1. As Section 5.1 of the submission notes, a task-vector profile supports only a stratum statement and an unnoised private coordinate can invalidate ordinary RDP. The submitted runs had both: the tied embedding and LM head were left unnoised (Appendix J.8). The new "formal" configuration uses a public profile (layer RMS of the public base model), noises every tensor that differs from the base, takes the frozen reference model from the executor's own view, and runs a single round, so no composition assumption is needed.
  4. Results in the formal configuration. At κ = 0.01, a view has cosine 0.81 to the fine-tuning delta, KL 0.0028 to the original model and 0.67% top-1 changes, and it remains a working model (Table 70). DARC's update error is 0.52–0.80 of the single view's across the four methods. DARC is closer than the single view in 12 of 12 paired runs, and closer than the independent average in 8 of 9 runs for NPO, SimNPO and UnDIAL and in 1 of 3 for GradDiff (Table 73).
  5. Exposure against noise. Table 70 covers κ = 0.01 to κ = 10 for one view. For two colluders out of three at κ = 1, the cosine rises from 0.71 to 0.89, as Theorem 1 predicts (γ(S) = 4).

In response to your review, Section 2 now states the difference from DECOR; Sections 6.2 and 6.4 and Appendix M give the matched comparison; Sections 3 and 5.1 and Tables 68 and 70 give the budget, its scope and a configuration within Theorem 1; and Algorithm 1's cross-reference is clarified. We would welcome your updated assessment. Relative to prior noise-cancellation work, the paper contributes first-order cancellation through a multi-step adaptive optimizer, with the decoder weights and key family this requires, and an exact coalition bound for the published views.

Thank you for the detailed rebuttal and additional experiments. However, I still have some questions about the following three points:

  1. The new formal configuration satisfies the assumptions of Theorem 1, but Table 68 shows that the privacy guarantee applies only within a relatively small parameter neighborhood, while Table 73 still reports non-negligible update errors. I encourage the authors to evaluate additional noise levels under the formal configuration, using NPO or SimNPO, and jointly report the privacy budget, parameter recovery error, relative update error, and unlearning performance. This would provide a more direct assessment of the confidentiality–fidelity trade-off and clarify which practical parameter-disclosure risks the guarantee meaningfully mitigates.

  2. Theorem 1 holds even when the transformation keys are revealed, while Appendix J.9 demonstrates highly accurate public-anchor alignment. Furthermore, the new matched comparisons use equal noise scales, under which inverse-scale weighting reduces to uniform averaging. I encourage the authors to provide targeted ablations comparing parameter recovery with and without reparameterization keys under matched noise settings, and comparing inverse-scale weighting against uniform averaging under heterogeneous noise scales. These experiments would help establish the distinct contributions and practical necessity of the individual components.

  3. Appendix J.6 reports non-negligible numerical discrepancies even for theoretically compatible transformations, while the new matched comparisons primarily focus on Llama-3.2-1B and TOFU Forget01. Could the authors clarify how randomness coupling and optimizer states were handled in Tables 71–73, and report the transformation-induced update discrepancies under the same experimental settings? Additionally, I encourage at least one compute-matched comparison against independent-noise averaging on a Qwen model or the MUSE dataset to assess whether the observed denoising improvements generalize across models or datasets.

Reviewer_SBtEOpenReview ↗
Rating
1
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper addresses the problem of unlearning private data from a server-owned model without sharing the original model weights or the private data between the server and the client. The authors propose DARC, which uses multiple executors, each of which receives a different noisy version of the model with a transformation applied to it. The noise is designed so that its first-order effect can be canceled when the updates are combined. Each executor performs unlearning locally using the private data, and the updates are then combined and applied to the original server model.

The authors provide theoretical analysis to support their method and conduct experiments comparing DARC with direct unlearning on the original model (Clean) and unlearning on a single noisy model. The results show that DARC performs close to the Clean reference in several metrics, but the improvements over the single noisy model are not always consistent.

Critical strengths

I think the first-order noise cancellation idea is a good part of the paper, and the authors provide theoretical analysis to support it. I also found the analysis of how different transformations can affect Adam optimization interesting.

Critical weaknesses
  1. My main concern is about the motivation and practical setting of the paper. I am not very familiar with this specific problem, and I don't think the motivation is clear enough. If the server originally trained the model using the private data, why would it not have access to the same data for unlearning? On the other hand, if the model was trained locally, why can't the client just perform unlearning using the original model? I think a clearer real-world example would help explain why this method is needed.
  2. I also have concerns about how the executor isolation would work in practice. The privacy guarantee depends on preventing the executors from combining too many model copies, but it is not clear who would manage these executors or how this would be enforced. For example, if the server manages them, how would the client's private data stay protected? And if they are managed by independent parties, what would prevent them from sharing their noisy model copies?
  3. I would also like to see more comparisons with existing privacy-preserving unlearning methods. Although the authors discuss related work, it is still not clear to me what the main advantages of DARC are compared to these methods, especially since it requires multiple executors and model copies.
Questions for authors
  1. Could the authors provide a clearer real-world example to explain the motivation?
  2. How would executor isolation be enforced in practice?
  3. Could the authors clarify the advantages of DARC compared to existing privacy-preserving unlearning methods?
2 comments
AuthorsOpenReview ↗

Response to Reviewer SBtE (1/2): W1 / Q1 and W2 / Q2

Your main concern is the motivation and the practical setting. The revision adds a concrete example (Section 1), a paragraph on who runs the executors and on the isolation assumption (Section 3), and a comparison with the alternatives (Appendix M). Table numbers refer to the revised PDF. The tables are also in the general response.

W1 / Q1. The motivation is not clear; please give a real-world example.

We added an example to Section 1. DARC is for the case where, at deletion time, the model owner does not hold the records to be forgotten and may not receive them, and the data owner may not receive the model's exact weights.

  1. "If the server originally trained the model using the private data, why would it not have access to the same data for unlearning?" Having the data at training time does not mean having it at deletion time. Providers delete raw records after training under retention limits, data may have arrived through a licensed feed or a partner that can no longer be queried, and a deletion request can name records that the provider cannot identify without the requester's copy.
  2. "If the model was trained locally, why can't the client just perform unlearning using the original model?" In our setting the server trained the model and owns the weights, and DARC is designed so that the exact checkpoint is not handed to the client's side. Executors receive noised, keyed copies, and Theorem 1 bounds how precisely fewer than m of them can determine the parameters. The model's function is not hidden, since an executor must evaluate the loss on the forget data (general response, A3).
  3. Example (an illustration, added to Section 1). A hospital network asks an LLM vendor to remove patient-derived records from a vendor-trained model. The hospital may not export those records to the vendor again, and the vendor will not hand over its exact weights, but both accept independent compute providers that the hospital authorizes. Each provider receives a differently noised and keyed copy, and the vendor decodes their updates.

W2 / Q2. Who manages the executors, and how is isolation enforced?

The client chooses them, and isolation is a non-collusion assumption between independent organizations; it is not enforced cryptographically. Section 3 now states both points.

  1. Who manages them. The server sends each view only to its assigned executor (Algorithm 1, line 3) and runs none of them, so it never receives the raw forget data. Returned updates can still reveal information about that data to the server; the submission leaves this outside its scope (Section 2; Appendix K).
  2. Precedent. Deployed private-aggregation systems make the same assumption. In Exposure Notifications Private Analytics, the two aggregation servers were operated by different organizations (ISRG and the US NIH), and the IETF Distributed Aggregation Protocol relies on it as well. In these systems, as in DARC, the parties are kept from sharing by organizational separation; no technical mechanism enforces it.
  3. If some executors share their copies. Theorem 1 gives the exact cost for every coalition size (Table 69). With five views, two colluders obtain 0.61 of the single-executor privacy radius, three obtain 0.41 and four obtain 0.25. The noise cancels only when all m views are combined, so m = 3 is the smallest setting that tolerates a colluding pair (0.50 of the radius).
  4. Limit. If one party controls all m executors, the guarantee is void. Section 3 now states this.
AuthorsOpenReview ↗

Response to Reviewer SBtE (2/2): W3 / Q3

W3 / Q3. What are DARC's advantages over existing privacy-preserving unlearning methods, given that it needs several executors and copies?

Among methods that train in plaintext, DARC returns a full-model update of the chosen unlearning method, with a bound, exact under the conditions of Theorem 1, on what any group of fewer than m executors learns about the parameters. Its costs are m non-colluding executors, m local runs, and no protection of the model's function.

  1. Comparison (Table 75). TEEs and MPC hide more, including the function, and need trusted hardware or heavy cryptography. Privacy-preserving federated unlearning protects the clients' data and shares the model in the clear, which is the opposite direction. Offsite-Tuning sends a compressed emulator and trains adapters only, so it changes which update is computed. We therefore compare these approaches by what they disclose and require. We do not compare them by update error, because TEEs and MPC return the exact update and Offsite-Tuning returns a different one, so there is no common noise-free update to measure against.
  2. Measured against the simplest alternative. A single noised copy gives the same per-executor privacy. Across four unlearning methods, three noise settings and three seeds, DARC's update is closer to the noise-free update in 36 of 36 paired runs, with 0.25–0.80 of the single copy's error (Table 73), at about twice the cost (Table 74). Against two independent noised copies at the same cost, it is closer in 25 of 27 runs for NPO, SimNPO and UnDIAL and in 4 of 9 for GradDiff. On a wider grid of six methods, its mean error is 8–48% below that of independent copies for four methods and on par for GradDiff and GradAscent (Tables 71, 72).
  3. Consistency of the improvement (your summary). Table 2 uses one seed, and at its noise level every arm stays close to the noise-free run in MU and the KS statistic, so those metrics cannot show a consistent difference. The matched comparison measures update fidelity, where DARC is closer than a single noised copy in every paired run (item 2). The claim is a more faithful update, which is the paper's stated objective (Section 1). For NPO at κ = 1, the output KL to the noise-free endpoint is 0.14 for one copy and 0.074 for DARC (Table 73).

If the example, the account of who runs the executors and the comparison answer your three questions, we would appreciate your reconsidering the rating. The paper offers a way to run a chosen unlearning method on data the model owner cannot hold, with an exact bound on what fewer than m colluding executors learn about the weights.

Reviewer_DXjcOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper studies LLM unlearning when the server keeps its model confidential and the client does not share its forget data with the server. The server sends mm copies of the model, each with zero-sum correlated Gaussian noise and a function-preserving coordinate permutation/rotation, to separate executors who run unlearning on the client's data. The server then combines the returned updates with inverse-scale weights, which cancels the first-order effect of the noise. The theory gives an exact Rényi-DP bound for coalitions of fewer than mm executors, a residual-error bound for the decoder, and Adam compatibility under signed permutations. Experiments use TOFU and MUSE with seven unlearning methods on Llama and Qwen models.

Critical strengths
  • The privacy bound for coalitions of fewer than mm executors is exact, and the paper proves that inverse-scale weighting cancels the first-order effect of the noise. I also appreciate that the appendix is upfront about when the guarantee fails (unnoised tensors, checkpoint-dependent profiles, all mm copies together).
  • The point that function-preserving keys can still change Adam's training path is useful. Signed permutations are exactly compatible with Adam while rotations are not, and the experiments back this up (final discrepancy 0.687 for rotations vs. 0.0538 for FFN permutations).
Critical weaknesses
  • I could not find a concrete privacy level in the paper. The neighbor radius Δ\Delta and (ε,δ)(\varepsilon, \delta) are never reported, and at the tested κ=0.01\kappa = 0.01, (1,10−5)(1, 10^{-5})-DP holds only for Δ≈0.003\Delta \approx 0.003 whitened units, which is tiny next to the task vector. Moreover, a single copy already behaves almost exactly like the original model (KL 2×10−72 \times 10^{-7}, 0/457 top-1 token disagreements, Table 64), so the model's function is effectively exposed to every executor.
  • It is hard to tell whether denoising actually helps. Table 2 uses a single seed, the noised baseline's MU is already within 0.003 of the clean model for most trainers, and most FQ gains are one step on the discrete KS pp-value grid (40 samples per side). In the only direct test (Fig. 3), the combined update (error 0.389) is worse than the best single copy (0.373).
  • I am not convinced by the motivating scenario. Executors are trusted with the raw forget data but not with the model, isolation is assumed rather than enforced, and the server still sees all updates, which can leak the forget data. Without a concrete deployment or a comparison with simpler options (e.g., a TEE or a single noised copy), it is unclear why the m×m\times training cost is worth it.
Questions for authors

Please see the weaknesses.

8 comments
AuthorsOpenReview ↗

Response to Reviewer DXjc (1/3): W1

Your two central concerns are that the paper reports no concrete privacy level and does not show whether denoising helps. The revision states the level (Section 5.1; Table 68) and adds a matched, multi-seed comparison (Sections 6.2, 6.4; Tables 71–73). The tables are also in the general response.

W1. The paper gives no concrete privacy level, the radius at κ = 0.01 is tiny, and a single copy already behaves like the original model.

  1. Level. At κ = 0.01 one executor's view is (1, 10⁻⁵)-DP within Δ = 0.0027 whitened units, and Δ = 0.003 corresponds to ε = 1.13 (Table 68). Theorem 1's conditions hold in the formal configuration; for the submitted runs the statement holds only in the restricted sense noted in Section 5.1. Δ grows linearly with κ: 0.27 at κ = 1 and 0.80 at κ = 3.
  2. Scale. In the same units the fine-tuning delta has norm 482 in the formal configuration and 3.1 × 10⁴ in the submitted one, and the model retrained without the forget set is 139 and 1.6 × 10⁴ away. At κ = 0.01 the guarantee therefore covers only small parameter differences and is not a record-level budget; Section 5.1 now says so. Because the bound is exact, κ sets this radius directly.
  3. Function. We measured the quantities of Table 64 on TOFU answer tokens with three noise seeds: at κ = 0.01 the KL is 1.1 × 10⁻⁷ with no top-1 change. Table 70 extends this to larger noise: a view remains a working model up to κ = 3 (forget QA probability 0.893 against 0.902, MU 0.597 against 0.598), although its cosine to the fine-tuning delta falls to 0.32 on the noised coordinates. An executor must evaluate the loss on the forget data, so any view that supports plaintext unlearning is functionally close; hiding the function requires a TEE or MPC.
  4. Scope. Section 3 now states that DARC provides parameter-level, bounded-coalition metric privacy and does not hide the function, and points to Tables 64 and 70 there.
AuthorsOpenReview ↗

Response to Reviewer DXjc (2/3): W2

W2. It is hard to tell whether denoising helps: one seed, MU already within 0.003, FQ on a coarse KS grid, and Figure 3.

We added a matched comparison with several seeds. Your reading of Table 2 is right: at κ = 0.01 every arm preserves utility, so TOFU's scalar metrics cannot separate the estimators. Theorem 2 concerns fidelity to the noise-free update. On that measure the zero-sum code lowers the error beyond what averaging independent views gives for four of six methods, and DARC is closer than a single view in every benchmark run (items 2 and 3).

  1. Matched arms. All arms share the client loop, optimizer, batches and seeds; the single view has the same marginal noise as one DARC view, and the independent average has the same compute as DARC. In Tables 71 and 72 the arms are formed from the same trained copies and differ only in how copies are combined.
  2. Update fidelity (Tables 71, 72; 3 data seeds × 3 noise seeds). Against the independent average, DARC's mean error is lower in all 72 cells (six methods with two copies, three with three copies, eight noise settings each): by 8–48% for NPO, SimNPO, UnDIAL and SatImp, and by 1–6% for GradDiff and GradAscent, where the two are on par. Seed by seed (m = 2, submitted configuration: six methods × six κ × nine seed pairs), it is lower in 207 of 216 and in 71 of 108 comparisons, respectively. Relative to one view, independent averaging of two leaves 0.72–0.83 of the error for the first four methods, and DARC leaves 0.37–0.74. For SimNPO at κ = 0.1, for example, the errors are 0.038 (single view), 0.028 (independent average) and 0.015 (DARC).
  3. Benchmark protocol (Table 73; 3 paired seeds). DARC is closer to the noise-free update than the single view in 36 of 36 runs, with 0.25–0.80 of its error, and closer in output KL in 34 of 36. Against the independent average it is closer in 25 of 27 runs for NPO, SimNPO and UnDIAL and in 4 of 9 for GradDiff.
  4. MU and KS. Averaged over seeds, every arm, including the single view, is within 0.014 MU and 0.034 KS statistic of the noise-free run in all 12 cells, which confirms your observation. The new comparison therefore uses continuous distances and the KS statistic instead of the p-value grid, and Section 6.2 now reads Table 2 as a utility-preservation result.
  5. Figure 3. The figure is a single GradDiff noise draw with three copies. Its best copy (0.373) is the one with the largest noise scale (α = 2), which suggests draw-to-draw variation, and it can only be identified with the clean reference; a copy chosen without that reference has mean error 0.460, against 0.389 for the aggregate. Over nine new draws with three equal-scale copies at κ = 0.01, the mean errors are 0.38 (one view, sd 0.18), 0.29 (independent average of three) and 0.28 (DARC) (Table 72). GradDiff is the objective where the code adds least over independent averaging (1–4%). Section 6.4 now describes Figure 3 as a single draw and reports the repeated-draw results next to it.
AuthorsOpenReview ↗

Response to Reviewer DXjc (3/3): W3

W3. The motivating scenario is not convincing: executors see the forget data but not the model, isolation is assumed, the server sees all updates, and no TEE or single-noised-copy comparison justifies the m× cost.

We added a concrete scenario (Section 1), a statement of the isolation assumption and of the effect of a violation (Section 3; Table 69), and measured comparisons with a single noised copy (Tables 73, 74).

  1. Why executors may see D_f but not θ. The trust assumption differs by role. The client chooses the executors and authorizes them to process its data. The server has no such relationship with them, so it limits what they learn about its parameters through coding and a collusion threshold.
  2. Scenario. See the hospital and LLM-vendor example in C1 of the general response; Section 1 now includes it as an illustration.
  3. Isolation. It is an organizational non-collusion assumption, the same one that deployed two-server private-aggregation systems make (C2). Section 3 now states that it is not cryptographically enforced. Theorem 1 gives the effect of a partial violation: with five equal-scale views, two colluders obtain 0.61 of the single-executor privacy radius and four obtain 0.25 (Table 69). With m = 2 the two executors together hold all views; m = 3 is the smallest setting that tolerates a colluding pair.
  4. Returned updates. We agree that returned updates can reveal D_f to the server. The submission leaves this outside its scope (Section 2; Appendix K) and notes it in the Ethics statement. Because Theorem 1 holds with keys revealed, executors could also align their own updates and run secure aggregation, after which the server sees only the decoded update. Appendix K now describes this option; we did not evaluate it.
  5. Single noised copy. It gives the same per-executor privacy as DARC at half the cost. DARC's update has 0.25–0.80 of its error, in 36 of 36 paired runs (Table 73), while MU and KS statistic agree within 0.014 and 0.034. Section 6.2 now states this trade-off.
  6. TEE. A TEE hides parameters and function from the executor, which DARC does not. It replaces non-collusion with trust in hardware and attestation, and it needs confidential-GPU capacity at the executor. DARC is for parties without that option (Table 75).
  7. What the m× cost gives. With m = 2, DARC takes 1.85–2.10× the end-to-end time of a single view at the same peak GPU memory (Table 74). The extra runs serve the paper's stated objective, an update faithful to the chosen unlearning procedure (Section 1), and the gain grows with κ. Under the benchmark protocol (Table 73, submitted configuration), every arm's update error at κ = 0.01 is below 6% of the update norm. At κ = 1, where the privacy radius is 0.27 (100 times larger), the single view's error is 0.24–0.57 and DARC's is 0.11–0.43; for NPO the output KL to the noise-free endpoint is 0.14 against 0.074. At equal compute, DARC is closer than two independent views in 25 of 27 paired runs for NPO, SimNPO and UnDIAL and in 4 of 9 for GradDiff.

The privacy level you computed is now moved in the main text (Section 5.1), the denoising claim is supported by a matched multi-seed comparison (Sections 6.2, 6.4; Appendix M), and the setting, its assumption and its cost are stated (Sections 1, 3, 6.2). If these changes address your three points, we would be grateful if you would reconsider your rating. The paper's core contribution is an exact coalition bound for published model views, together with a decoder that cancels the first-order effect of their noise on the unlearning update and keys that keep Adam aligned.

Comments on the paper

4 comments
AuthorsOpenReview ↗

General response (1/3): summary, protocol, and the privacy level

The three reviews credit the first-order cancellation analysis and the optimizer-compatible keys, and share three questions: (A) what privacy level DARC provides, (B) whether authorized denoising helps beyond a single noised view, and (C) the setting and its alternatives. We ran new experiments for each on Llama-3.2-1B / TOFU forget01. The revised PDF marks its changes in blue: short clarifications in Sections 1–6 and a new Appendix M (Tables 68–75, the numbers used below). No theorem and no original result is changed.

  • A. The reviewers' observation matches what the submission reports (abstract; Appendix J.9): one view behaves like the original model, and the guarantee is local and parameter-level. The submission did not give the numerical level, which is now in Section 5.1 and Tables 68 and 70.
  • B. With matched arms and several seeds, DARC's mean update error is below that of a compute-matched average of independent views in all 72 configurations (six unlearning methods, two or three copies): 8–48% lower for four methods and on par (1–6% lower) for GradDiff and GradAscent. Under the benchmark protocol it is closer to the noise-free update than a single noised view in 36 of 36 paired runs (Tables 71–73; part 2/3).
  • C. Setting, enforcement, alternatives and measured cost are in part 3/3.

Protocol for all new results. Every arm (noise-free, single view, independent average, DARC) runs the same client loop, AdamW settings, batches and seeds. The single view has the same marginal noise as one DARC view and therefore the same per-executor privacy. The independent average uses m views with independent noise, so it costs the same compute as DARC (m = 2 unless stated). Keys are FFN permutations and RoPE quarter turns (the Adam-compatible family of Theorem 3). Copy scales are equal, the choice that minimizes the privacy–curvature factor of Proposition 4. All new comparisons use FP32 parameters, since bf16 storage rounds away most of the perturbation at κ ≤ 0.1. "Submitted" is the noise configuration of the submission: task-vector profile, noise on the transformer layers. "Formal" meets the conditions of Theorem 1: a public profile (layer RMS of the public base model), noise on every tensor that differs from the public base, and a frozen reference model taken from the executor's own view.

A1. Budget (Table 68). Radius Δ, in whitened units, within which one executor's view is (ε, 10⁻⁵)-DP, for m = 2 and t = 1 (Theorem 1, Eq. (29)).

κΔ at ε = 1Δ at ε = 3Δ at ε = 8
0.010.002680.007190.0167
0.10.02680.07190.167
10.2680.7191.67
30.8042.165.00

Δ is linear in κ. This agrees with Reviewer DXjc's estimate: at κ = 0.01, Δ = 0.003 corresponds to ε = 1.13. Theorem 1's conditions hold in the formal configuration; for the submitted one the radius holds only in the restricted sense noted in Section 5.1.

A2. Scale. In the same units, the fine-tuning delta τ = θ − θ_base has norm 3.1 × 10⁴ in the submitted configuration, and the model retrained without the forget set lies 1.6 × 10⁴ away (482 and 139 in the formal configuration). The guarantee is therefore local: it bounds what a coalition can infer about small parameter differences, and κ sets the radius exactly. It is not a record-level budget, which Section 3 notes would require a separate sensitivity certificate.

A3. Exposure of one view (Table 70). The cosine is taken over the noised coordinates, and KL and top-1 changes are measured against the original model on TOFU answer tokens; these three columns are means over three noise seeds. The last two columns evaluate one view as a model.

Configurationκcos(view − base, τ)KL to originalTop-1 changedForget QA prob. of viewMU of view
Original model01000.9020.598
Submitted0.011.0001.1×10⁻⁷0.00%0.9020.598
Submitted10.7070.00110.47%0.9010.599
Submitted30.3160.0101.32%0.8930.597
Submitted100.1000.188.68%0.7610.554
Formal0.010.8130.00280.67%0.9000.599

A view remains a working model up to κ = 3, where its cosine to the fine-tuning delta is 0.32. The submission claims bounded-coalition checkpoint privacy and states that it is not cryptographic model secrecy (Ethics statement; Appendix B.6), but these caveats were outside the main text, while Section 3 lists functional recovery among the executors' goals. The revision states in Section 3 that DARC does not hide the function, and Section 1 now calls the checkpoint "proprietary" instead of "confidential". Tables 71 and 73 give the update error at each κ.

AuthorsOpenReview ↗

General response (2/3): does authorized denoising help?

We justify the effect of authorized denoising in terms of fidelity to the noise-free update, which is the quantity Theorem 2 concerns.

B1. Update fidelity across noise levels (Tables 71, 72). Relative error ‖Δ_arm − Δ_clean‖ / ‖Δ_clean‖ of each arm's decoded update against the noise-free update of the same run. 40 AdamW updates with one forget and one retain example each, with 3 data seeds × 3 noise seeds. The arms are formed from the same trained copies and differ only in how copies are combined: one copy, two copies with independent noise, or the two zero-sum partners. Excerpt of Table 71; mean (sd).

MethodκSingle viewIndep. avg (2)DARC (2)DARC / singleDARC / indep.
NPO0.010.00900 (0.0033)0.00688 (0.0021)0.00444 (4.9×10⁻⁴)0.490.65
NPO0.10.0681 (0.055)0.0532 (0.036)0.0378 (0.049)0.550.71
NPO10.356 (0.12)0.291 (0.10)0.246 (0.12)0.690.85
SimNPO0.010.00654 (5.5×10⁻⁴)0.00510 (3.1×10⁻⁴)0.00381 (3.4×10⁻⁴)0.580.75
SimNPO0.10.0381 (0.0047)0.0285 (0.0023)0.0151 (0.0022)0.400.53
SimNPO10.302 (0.063)0.230 (0.038)0.166 (0.047)0.550.72
GradDiff0.010.396 (0.17)0.318 (0.14)0.306 (0.15)0.770.96
GradDiff0.10.704 (0.12)0.594 (0.095)0.579 (0.11)0.820.97
GradDiff10.956 (0.090)0.813 (0.068)0.804 (0.071)0.840.99
NPO, formal0.010.466 (0.12)0.381 (0.11)0.321 (0.12)0.690.84
SimNPO, formal0.010.469 (0.10)0.373 (0.083)0.309 (0.079)0.660.83
GradDiff, formal0.011.03 (0.082)0.884 (0.075)0.866 (0.059)0.840.98

Ratio ranges over all eight noise settings (κ = 0.01 to 3 submitted; κ = 0.003, 0.01 formal) for three more methods (Table 71) and for m = 3 (Table 72; independent average of three views).

Method, mDARC / singleDARC / indep.
UnDIAL, 20.43–0.700.58–0.87
SatImp, 20.37–0.710.52–0.88
GradAscent, 20.76–0.830.94–0.98
NPO, 30.41–0.660.70–0.90
SimNPO, 30.35–0.680.58–0.92
GradDiff, 30.72–0.790.96–0.99
  1. Against the independent average at equal compute, DARC's mean error is lower in all 72 cells (six methods with m = 2, three with m = 3, eight noise settings each): by 8–48% for NPO, SimNPO, UnDIAL and SatImp, and by 1–6% (inside one sd) for GradDiff and GradAscent. Seed by seed (m = 2, submitted: six methods × six κ × nine seed pairs), it is lower in 207 of 216 and in 71 of 108 comparisons, respectively.
  2. An average cannot exceed the mean error of the copies it combines, so the single-view column gives the scale of the effect: with m = 2, independent averaging leaves 0.72–0.83 of a single view's error for the first four methods, and DARC leaves 0.37–0.74.

B2. Benchmark protocol (Table 73). Batch 8, accumulation 4, clipping 1.0, ten epochs, one round, m = 2; three paired seeds, each fixing batches, noise and keys for all arms. Output KL is the token-mean KL between the noise-free endpoint and each arm's endpoint.

MethodNoiseUpdate error: single / indep. / DARCDARC closer than single; indep. (seeds)Output KL to clean: single / indep. / DARC
NPOκ = 10.310 / 0.222 / 0.1823/3; 2/30.14 / 0.095 / 0.074
NPOκ = 0.010.00587 / 0.00424 / 0.002353/3; 3/32.1×10⁻⁴ / 4.0×10⁻⁴ / 5.8×10⁻⁷
NPOformal, κ = 0.010.422 / 0.345 / 0.3113/3; 2/30.21 / 0.18 / 0.18
SimNPOκ = 10.242 / 0.173 / 0.1073/3; 3/30.023 / 0.017 / 0.0068
SimNPOκ = 0.010.00530 / 0.00393 / 0.002493/3; 3/33.3×10⁻⁶ / 2.1×10⁻⁶ / 3.0×10⁻⁸
SimNPOformal, κ = 0.010.367 / 0.260 / 0.1923/3; 3/30.062 / 0.035 / 0.026
UnDIALκ = 10.238 / 0.185 / 0.1533/3; 3/30.0092 / 0.0064 / 0.0046
UnDIALκ = 0.010.00577 / 0.00340 / 0.001423/3; 3/31.0×10⁻⁵ / 2.3×10⁻⁶ / 6.4×10⁻⁷
UnDIALformal, κ = 0.010.326 / 0.252 / 0.2043/3; 3/30.017 / 0.011 / 0.0078
GradDiffκ = 10.570 / 0.441 / 0.4343/3; 1/36.0 / 4.1 / 3.4
GradDiffκ = 0.010.0559 / 0.0316 / 0.02933/3; 2/30.027 / 0.016 / 0.015
GradDiffformal, κ = 0.010.695 / 0.543 / 0.5533/3; 1/35.5 / 4.2 / 4.3
  1. DARC is closer to the noise-free update than the single view in 36 of 36 paired runs, with 0.25–0.80 of its error, and closer in output KL in 34 of 36.
  2. Against the independent average, DARC is closer in 25 of 27 runs for NPO, SimNPO and UnDIAL, and in 4 of 9 for GradDiff.

B3. Scalar metrics. In all 12 cells the seed-averaged MU, KS statistic and forget QA probability of every arm, including the single view, are within 0.014, 0.034 and 0.019 of the noise-free run.

AuthorsOpenReview ↗

General response (3/3): settings, enforcement, alternatives, cost

C1. Settings. DARC is for deletion requests in which the model owner (server) no longer holds, or may not receive, the records to be forgotten, and the data owner (client) may not receive the exact model weights. Executors are independent compute providers that the client authorizes to process its data. The trust placed in executors differs by role: they may see the forget data because the client chose them, while the server limits what they learn about its parameters through coding and a collusion threshold. Section 1 now gives an illustration: a hospital network asks an LLM vendor to remove patient-derived records from a vendor-trained model. The hospital may not export the records to the vendor again, and the vendor will not hand over its exact weights.

C2. Enforcement. Executor isolation is an organizational non-collusion assumption, as in two-server private-aggregation systems (ENPA, whose two aggregators were run by ISRG and the US NIH; the IETF DAP protocol). Section 3 now states that it is not cryptographically enforced. Theorem 1 gives the exact effect of a partial violation (Table 69, equal copy scales): the radius shrinks step by step until all m views are pooled. With m = 2 the two executors together hold all views, so m = 3 is the smallest setting that tolerates a colluding pair; its update fidelity is in Table 72.

Views mColluding executors sPrivacy radius relative to one executor
320.50
520.61
530.41
540.25
840.38
870.14

C3. Alternatives (Table 75, qualitative).

ApproachData side learns about the modelUpdate the server obtainsRequirement
Direct or federated unlearningExact weightsExactNone
Privacy-preserving federated unlearningExact weights (it protects the clients' data)Exact or DP-noisedSecure aggregation or DP
Trusted execution environmentNothing, if the enclave holdsExactTrusted hardware and attestation at the executor
MPC or secret sharingNothingExact up to arithmeticHeavy cryptographic overhead for full-model training
Offsite-TuningA lossy emulator and the adaptersAdapter-only, computed on the emulatorEmulator construction
Single noised viewFunction; parameters up to the noiseFull-model, with noise-induced errorNone
DARCFunction; parameters up to the noise, with an exact bound for up to t colludersFull-model, with lower noise-induced error (Tables 71–73)m non-colluding executors and m local runs

C4. Cost (Table 74, measured). m = 2, views trained one after the other on the same GPU.

Arm (NPO, κ = 1)End-to-end timeTraining timeSent to executors
Direct unlearning (no noise)72 s67 s4.9 GB
Single view89 s66 s4.9 GB
Indep. avg (2)172 s136 s9.9 GB
DARC (2)185 s131 s9.9 GB

Across the 12 benchmark cells, DARC with m = 2 takes 1.85–2.10× the end-to-end time of a single view (training time is 2×) at the same peak GPU memory. The independent average has the same training compute and communication as DARC. By design the cost is m local runs. Tables 71–73 compare the resulting update error with that of one run and of m independent runs.

D. Changes in the revised PDF (in blue). To make the new experiments easy to find, the revision collects them in a single appendix (Appendix M). If the paper is accepted, we will move them to the appropriate sections in the camera-ready version.

  • Section 1: an illustrative scenario and why a model owner can lack the records at deletion time; "proprietary" replaces "confidential" for the checkpoint; isolation is called an assumption.
  • Section 2: one sentence on the difference from DECOR.
  • Section 3: who runs the executors, the non-collusion assumption, and that the function is not hidden.
  • Algorithm 1, line 1: the noise now cites Section 4.1. Line 3 already sends T(θ + αe), the order of Eq. (5) and of the code.
  • Section 5.1: the numerical privacy level and the configuration in which Theorem 1 applies.
  • Section 6.2: Table 2 read as utility preservation; the matched comparison and its cost.
  • Section 6.4: Figure 3 described as a single draw, with repeated-draw results next to it.
  • Appendix K: an executor-side secure-aggregation option (not evaluated).
  • Appendix M: Tables 68–75.
AuthorsOpenReview ↗

Summary of the discussion: what the rebuttal added

For each concern in the reviews, the rebuttal added new experiments or a clarification. No theorem and no original result changed. The table lists each addition and where to find it.

Concern (raised by)What was addedWhere
No concrete privacy level; one view behaves like the original model (DXjc W1, iUzB W2)The level is stated: at κ = 0.01 one view is (1, 10⁻⁵)-DP within Δ = 0.0027 whitened units, and Δ is linear in κ. The text now says that DARC bounds what a coalition learns about the parameters and does not hide the functionSections 3, 5.1; Tables 68, 70
Some settings do not meet the conditions of Theorem 1 (iUzB W2)A "formal" configuration that meets all of them, with the comparisons repeated in itAppendix M; Tables 70–73
Whether denoising helps; unmatched comparisons; one seed (DXjc W2, iUzB Q3)Matched arms and several seeds. DARC's mean update error is below that of a compute-matched average of independent views in all 72 configurations, and DARC is closer to the noise-free update than a single view in 36 of 36 paired benchmark runsSections 6.2, 6.4; Tables 71–73
When denoising is needed at larger noise (DXjc, follow-up)The formal configuration at κ = 0.02 to 0.1. DARC returns the higher MU in all 24 paired runs and the lower update error in all 24. At κ = 0.1 the single view's MU is 0.011 below the noise-free run and DARC's is within 0.005Our follow-up to Reviewer DXjc
The confidentiality–fidelity trade-off, the role of each component, and the scope of the matched comparison (iUzB, follow-up)One table with the budget, recovery error, update error and unlearning metrics at five noise levels; ablations of the keys and of inverse-scale against uniform decoding (lower mean error in all 18 cells); the update discrepancy caused by the keys alone; the matched comparison repeated on TOFU forget10, where DARC's mean error is below the independent average's in all six cellsOur follow-up to Reviewer iUzB
Motivation; who runs the executors; isolation (SBtE W1, W2; DXjc W3)An example, and why a model owner can lack the records at deletion time. Isolation is stated as a non-collusion assumption, with the exact effect of partial collusionSections 1, 3; Table 69
Alternatives and the m× cost (SBtE W3, DXjc W3)A comparison with TEEs, MPC, Offsite-Tuning and a single noised view, and the measured cost: 1.85–2.10× a single view for m = 2Tables 74, 75
Relation to DECOR; Algorithm 1 and Eq. (5); Figure 3 (iUzB W1, Q3; DXjc W2)The difference from DECOR; the cross-reference in Algorithm 1; Figure 3 described as a single draw, with repeated-draw results next to itSection 2; Algorithm 1; Section 6.4

Changes in the revised PDF are in blue, and its new experiments are collected in Appendix M; the results of the two follow-ups were obtained after the PDF was uploaded and are given in those responses. Reviewer DXjc has confirmed that the multi-seed comparison addresses W2 and that the remaining points of W3 can be treated as stated limitations. We would be grateful if the reviewers and AC can reevaluate the paper based on the revised version.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.