acceptodds
Under review as a conference paper at ICLR 2027

ARIAD: Adaptive Trajectory Matching for Prompt Reconstruction

Abstract

Distributed inference exposes intermediate states even when prompt text remains on the client. We introduce Adaptive Prompt Reconstruction from Internal Anchor Dynamics (ARIAD), which reconstructs a request by fitting and verifying a compact internal trajectory, without training an inverse model. An endpoint fit supplies provisional tokens; self-generated substitutions select internal anchors, and fixed target statistics define a shared metric for embedding optimization and causal token verification. We analyze the standardized cosine used by the attack: different depths can resolve different local ambiguities, while candidate omissions limit exact decoding. Controlled experiments separate conditioning, trajectory coverage, verification, and adaptive placement. Across five white-box initializations, ARIAD reaches .9806 accuracy and .6067 exact match, exceeding dual endpoints by .0069 and .0387. On 150 additional requests after independent validation selection, its accuracy is .9869 versus .9762 for a conditioned boundary; exact-match counts are 101 and 104. Shared-fit verification improves partial reconstruction without changing exact match, while larger proposal sets improve candidate coverage. Permitted-target black-box experiments further test adaptive placement under model mismatch. Experiments across domains, depths, model families, generated identifiers, and longer requests reveal both recovery gains and limits.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
prompt reconstruction, internal representations, adaptive verification, distributed inference

Reviews

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

This paper considers the following threat model: an adversary has access to the per-layer intermediate activation of an unknown target prompt, and their goal is to recover the target prompt. If the original prompt involves private information, this can be problematic.

In essence, this attack requires finding the set of prompts (or sequence of tokens) that induces the same activation as the target’s activation. Since tokens are discrete and hard to optimize for, previous methods such as PIA finds the embedding that leads to the most similar activation to the target’s activation instead, and then find the tokens from there. However, PIA optimize for the best embedding using only one layer of the target’s activation, specifically, they find the embedding that has the smallest Euclidean distance from the target’s activation at one layer.

This paper’s proposed method, ARIAD, selects an anchor set of more than one layer and leverage activations in the anchor set to better recover the target prompt. Specifically, the anchor set always constitutes the first- and the last-layer of the target’s activations, and the most “sensitive” middle layers selected by comparing the change in the activations by replacing one token by another one in a candidate set. Then, they find the best embedding by minimizing its average cosine similarity to the target’s activations in all layers in the anchor set. On multiple benchmarks, and for multiple attack positions, they show that their method slightly outperforms previous methods.

Critical strengths
  • The authors demonstrate that their proposed method outperforms existing baselines in accuracy and other metrics through extensive experiments. They also provide multiple ablations on different components.
Critical weaknesses
  • The paper is somewhat difficult to follow for me. It would be helpful, for example, to specify the attack model more clearly and to provide a more detailed description of the proposed algorithm.
  • While the pipeline of ARIAD appears quite similar to that of PIA, the paper does not provide a discussion on their similarities, (e.g. the fitting of the embedding and the verification process).
Questions for authors
  • Why do you select the internal anchor set by comparing log⁡det⁡(ϵIB+∑q∈ASq⊤Sq)\log \det (\epsilon I_B + \sum_{q \in \mathcal{A}}S_q^\top S_q)?
  • Can you further explain the complementary local constraints?
  • Table 39 shows that multiple initialization of the Boundary method significantly improves the reconstruction accuracy. Can you provide more details of this (e.g. do different initializations lead to drastically different recovered tokens?) Would a better initialization method improve ARIAD?
3 comments

We thank Reviewer for the positive assessment of our experiments and ablations, and for the questions on planning and initialization, which helped us explain the method more clearly.

W1. Specify the attack model and give a more detailed algorithm.

Sec. 2.1 specifies the attack model. Sec. 3 gives the three stages with equations, and Algorithms 1–2 (Appendix C) give the pipeline and the verifier step by step.

W2. Discuss the similarities to PIA.

Table 1 compares PIA and ARIAD stage by stage. It marks the inherited components (constrained embedding fit, embedding/LM candidate union, causal verification) and the three changes (the observations matched, the metric, and planning).

Q1. Why select anchors by log det(εI + Σ SᵀS)?

Each probe response S_q records how token substitutions move the state at depth q. The log-determinant measures the volume these responses span across the selected depths. A depth therefore raises it only if it moves the probes in directions the current anchors do not already cover. The objective is submodular, so greedy selection is within 1 − 1/e of optimal (Appendix B.4). Sec. 3.1 now states this intuition.

Q2. Explain the complementary local constraints.

Sec. 4 now explains this in three steps before the algebra. A perfect cosine fixes only a ray (Lemma 1). Linearizing the standardized cosine at an exact fit gives each depth a positive semidefinite matrix G_q whose null space contains the perturbations that depth cannot detect. Because ker(Σ w_q G_q) = ∩ ker G_q, a perturbation is invisible to the trajectory only if every anchor misses it. A depth that resolves a direction the others miss adds a real constraint; a duplicate depth adds none.

Q3. Multiple initializations improve the boundary a lot. Do different initializations give very different tokens? Would a better initialization help ARIAD?

Yes. Under the restart budget, boundary exact match rises from .571 with one start to .891 with three (table under mDL3-W2), so for about a third of the requests a later start recovers the prompt exactly where the first did not: different initializations do reach different token sequences, and agreement-selected restarts pick the better ones. A better initializer would likely help ARIAD as well: splitting ARIAD's own budget into four starts raises its exact match from .800 to .851 at equal cost (Figure 9). The sharper comparison is adding anchors versus repeating the search at equal cost: in black box, adding anchors beats three restarts in less than half the time (Table 36), because the extra anchors constrain the fit directly instead of resampling it. The restart harness (budget.py) is released for further study.

With the attack model, the comparison to PIA, and the rationale for each component now stated explicitly, we hope the reviewer finds the paper substantially clearer and would be willing to reconsider the rating.


We believe these revisions address the concerns on soundness and clarity, and we are glad to run any further control the reviewers would find decisive.

Thank you for your response and for the revisions to the manuscript. The updated version addresses my concerns regarding the threat model, and I appreciate the cumulative ablation study in Table 3, which helps clarify the sources of improvement.

However, the improvement over PIA appears to be relatively modest: Table 3 suggests that most of the gains in the white-box setting come from target standardization, while incorporating the trajectory provides a relatively modest additional benefit. Therefore, I have decided to keep my current score.

Thank you for the follow-up, and we are glad the revision resolves your concerns on the threat model and that the cumulative ablation in Table 3 clarifies the sources of improvement. We would like to address the remaining point briefly, because we believe Table 3 supports a stronger reading.

1. Target standardization is part of ARIAD, so Table 3 shows a large improvement over PIA. PIA matches raw features; standardizing by the observed target's statistics is one of ARIAD's components, introduced in this paper. The comparison with PIA is therefore the full Table 3, and the gain is robust to tuning:

Qwen2.5-7B, deep positionPIAARIAD
Exact match (Table 3).200.540
Entity recovery (Table 2).830.950
Complete prompts, every method's learning rate tuned on validation (Table 19)84101
Token errors, tuned learning rates (Table 19)2.06%1.31%

Over repeated initializations, ARIAD's accuracy gain over PIA is +.0368 [.0251, .0486].

2. The trajectory's white-box increment is small in absolute terms because the remaining error is small, not because the gain is weak. After standardization, accuracy is already near .97. Each trajectory component in Table 3 has an interval excluding zero, and together, over five initializations, they remove 28% of the remaining token errors (+.0076 [.0021, .0131]) and recover 31 more complete prompts across 750 paired runs (+.041 [.011, .072]). On Qwen2.5-3B and ECHR the gain over the standardized boundary is nearly four points (+.0387 and +.0364, Table 16).

3. The trajectory is the decisive component once the attacker's model differs from the victim. Table 3 is white box, where the later states can be recomputed from the boundary, so it is the hardest setting for the trajectory by construction. When they cannot be recomputed, ARIAD reaches .765 black-box accuracy, against .524 for the standardized boundary and .552 when an L2 magnitude term is added (Table 4). At equal cost, adding anchors also beats repeated restarts by +.068 [.058, .077].

In short, ARIAD improves substantially over PIA even after tuning, standardization and the trajectory are both contributions of this paper, and the trajectory is what keeps the attack effective under model mismatch. With the threat-model concern resolved, we would be grateful if you would consider raising your score.

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

This paper studies prompt reconstruction in distributed ( a pipeline-parallel fashion) LLM infra. An honest-but-curious worker receives a hidden state from an upstream participant and tries to recover the user's prompt from it. ARIAD, what authors proposed, changes the previous method PIA in three major ways: (1) it rescales the hidden-state features before comparing them, (2) it also matches the outputs of later layers that the attacker computes itself, and (3) it chooses those layers separately for each prompt. On Qwen2.5-7B, ARIAD recovers 54% of prompts exactly, compared with 20% for PIA.

Critical strengths
  • The problem is interesting. Some systems will indeed split models across machines run by different parties, and the paper shows that a curious machine can recover many prompts word for word.
  • Reporting entity leakage alongside exact match is useful and matches privacy-related work's conventions. Even when few full prompts are recovered, many names and identifiers still leak, and this matters.
Critical weaknesses

W1. It is for sure not an easy-to-follow paper. One issue with the presentation, I think, is that the threat model isn't explicitly defined at the beginning. I noticed related text about the attacker's ability is spread across the beginning of Section 3.1 and somewhere in the appendix. I guess it is better to set it as a separate subsection before 3.1.

W2. Following W2, the writing is dense, and many terms are used but explained or introduced later. And more importantly, I found it difficult to identify which experimental results represent the final method. Many results are scattered across roughly 40 pages of appendix, including archived and diagnostic runs affected by engineering-side corrections. Specifically, Table 15 reports 54% exact match for ARIAD on Qwen2.5-7B, while Table 39 reports 85.1% in a separate resource experiment. My guess is that these are different runs, but their relationship is not clearly explained. And even within Table 39, two ARIAD profiles report 85.1% and 80.0% under the same stated nominal settings, without specifying the implementation differences. I encourage the authors to make the final, directly comparable results much easier to identify.

W3. I am not very convinced that the method addresses the main cause of failure. The paper’s own analysis shows that when the attack fails, the correct word was never proposed as a candidate; once it is proposed, it is almost always chosen (Table 22). None of ARIAD’s new components change how candidates are proposed. Ans simply enlarging the candidate list raises ARIAD’s exact match from 54% to 72% (Table 30), a much larger gain than the extra layers and layer selection give. Since this test is run only for ARIAD, it is unclear whether its advantage over the baselines remains once all methods use a larger list.

W4. In the white-box setting, I don't think the later layers will give the attacker new information. The attacker has the model weights in this case, so they can compute the later layers directly from the hidden state it received. Two prompts that produce the same received state will therefore produce the same later layers too. The extra layers seem to help because the attack compares states with cosine similarity, which checks the direction of a vector but ignores its length (Lemma 1). A wrong guess can match the direction at the received layer while the later layers expose the mismatch. However, if it is the case, a simpler fix is to just check length at the received layer, for example by adding an L2 distance to the loss. If ARIAD still wins, the extra layers help in some other way (maybe they make the search easier), and the paper should show that. If it doesn’t, the trajectory isn’t needed.

Questions for authors

See W1-W4

3 comments

We thank Reviewer for the careful reading and for proposing two concrete controls, an L2 term at the boundary and a larger candidate budget for every method; both are now run and reported in the main body.

W1. The threat model is not defined up front.

Fixed. Sec. 2.1 is a dedicated subsection before the method. It covers the system, the honest-but-curious adversary, what it records, and the three knowledge regimes.

W2. Hard to identify the final results: 54% (old Table 15) vs. 85.1% (old Table 39), and two ARIAD profiles (85.1% and 80.0%) under seemingly identical settings.

These numbers measure different things. The revision states each one's configuration:

NumberWhat it isConfigurationPaper
54.0%ARIAD EM, single run (headline)1 init, 2,000 steps, 10/10 candidatesTable 2
80.0%ARIAD, restart budget1 start × 2,000 steps, mean of 3 seedsFigure 9
85.1%ARIAD, same budget4 starts × 500 steps, best objective keptFigure 9
57.1 / 81.1 / 89.1%Boundary (std.), restart budget1 / 2 / 3 full startsFigure 9

The two ARIAD profiles differ only in the restart schedule and are now labeled "single start" and "four starts". Restart-budget values are selected by objective agreement and are not comparable with single-run EM; Sec. 5.1, Sec. 5.5, and the Figure 9 caption say so. We removed the old Table 39, merged the per-initialization decoder tables, and dropped the archived certification and timing tables.

W3. The real failure cause is candidate omission; enlarging the list raises EM from 54% to 72%; this test was run only for ARIAD.

We agree, and this is now a stated result: Sec. 4 proves that exact match is bounded by candidate coverage (Theorem 1, Corollaries 1–2), and Table 5 runs the larger budget for every method:

MethodEM 10/10EM 20/20Recall 10/10Recall 20/20
PIA.200.340.9708.9827
Boundary (std.).540.660.9817.9900
ARIAD.540.720.9858.9919

All methods improve, while a four-wide beam at 10/10 leaves ARIAD at .540. ARIAD keeps PIA's proposal rule, so no new component changes how candidates are proposed. The fit does change which candidates appear, because the embedding neighbors come from the fitted embeddings: ARIAD has the highest recall at both budgets, ties Boundary (std.) at 10/10, and leads at 20/20 (108 vs. 99 of 150 exact). The recall gap narrows as all methods approach full coverage, and we say so. Any method can be run this way with pti.py --pad-top-k-cos / --pad-top-k-ppl.

W4. In white box the later layers are recomputable; the trajectory may only offset cosine's indifference to magnitude (Lemma 1); an L2 term at the boundary would be simpler.

  • Conceptually, the trajectory carries no new data in white box. Its value is that it adds independent angular constraints (Sec. 4, Eq. 7): a perturbation the boundary's angular test cannot see can be constrained at a later depth. This differs from the single radial (magnitude) direction of Lemma 1.
  • Empirically, we ran exactly the suggested control: a squared-error term added to the standardized boundary loss (--boundary-l2-weight), reporting the best of W ∈ {0.1, 0.3, 1.0} per setting (Table 4; full sweep in Figure 5):
MethodWB Acc.WB EMWB NERRBB Acc.
Boundary (std.).961.540.922.524
+ L2 (W = 0.3 WB, 1.0 BB).967.540.934.552
ARIAD.975.540.950.765

The magnitude term helps a little but stays below the trajectory, by 21.3 accuracy points in black box. The trajectory therefore helps in a way that an L2 term at the boundary does not.

With both requested controls run for every method and the final results identified explicitly, we believe the main concerns are resolved, and we would greatly appreciate it if the reviewer would consider raising the score.

Thank you for the rebuttal. I consider W1–W2 resolved at this stage and have raised my presentation score from 1 to 2. I also appreciate that both controls I requested were run for every method.

Given the time this rebuttal was submitted, I acknowledge that there was not enough time for further verification. However, my main concerns (W3–W4) remain, and the new experiments seem to confirm them.

In the white-box setting, ARIAD's accuracy advantage over the L2 control is less than one point (.975 v.s. .967), with identical exact match (likely within the 95% confidence interval?). At the default candidate budget, ARIAD and the standardized boundary also tie. The remaining white-box advantage seems small and inconsistent: the boundary performs better on Phi-3.5 and CMS, and in the independent test with validation-selected learning rates (Table 19), it recovers more complete prompts than ARIAD (104 vs. 101). The 20/20 lead (108 vs. 99), meanwhile, comes from a single initialization without an uncertainty estimate.

Overall, the revision is much clearer, and the experiments are carefully conducted. Thanks again for the effort. Still, the main claimed contribution seems to offer only a modest, setting-dependent gain in white box, while the largest improvement over PIA may partly come from optimization choices. Therefore, I will keep my score.

Thank you for the follow-up and for raising the presentation score. We respectfully believe the remaining concern rests on comparing ARIAD with an ablation of itself, in the one regime where our analysis predicts the smallest gap, using single-initialization counts. The full evidence shows a consistent contribution, and a decisive one under model mismatch.

1. Boundary (std.) is ARIAD without the trajectory, not prior work. Target standardization is one of ARIAD's components, introduced in this paper; we built Boundary (std.) to isolate it. Against the actual prior method, the gain survives tuning: with every method's learning rate selected on held-out validation (Table 19), ARIAD recovers 101 vs. 84 complete prompts and makes 36% fewer token errors than PIA (.9869 vs. .9794). Over repeated initializations, ARIAD's accuracy gain over PIA is +.0368 [.0251, .0486].

2. In white box, the trajectory's gain over its own ablation is significant in three of four settings (paired intervals over repeated initializations, Table 16):

ARIAD − Boundary (std.)Accuracy Δ [95% CI]
Qwen2.5-7B+.0076 [.0021, .0131]
Qwen2.5-3B+.0387 [.0250, .0521]
ECHR+.0364 [.0249, .0482]
Phi-3.5−.0524 [−.0630, −.0417]

On Qwen2.5-3B and ECHR the gain is nearly four points. On Qwen2.5-7B accuracy is near ceiling, so +.0076 removes 28% of the remaining token errors, and across 750 paired runs ARIAD recovers 31 more complete prompts (455 vs. 424; EM +.041 [.011, .072]). Every trajectory component also has an interval excluding zero (Table 3). Phi-3.5, and CMS in exact match, are the exceptions, and we report them.

3. Exact-match ties at the default budget are predicted by our coverage theorem. ARIAD and Boundary (std.) share PIA's candidate rule, and Theorem 1 with its corollaries shows that exact match is capped by candidate coverage, which is exactly your W3 point. At 10/10 this cap binds for both methods, so exact match there measures the shared verifier's ceiling, not fit quality. ARIAD's better fit shows up where the theorem says it should: higher true-token recall at every budget (.9858 vs. .9817 at 10/10; .9919 vs. .9900 at 20/20) and more complete recoveries once the cap is relaxed (108 vs. 99). Single-initialization differences of a few prompts, whether 104 vs. 101 (Table 19) or 108 vs. 99, are within noise in either direction; the five-initialization pooled estimate is the reliable one, and it favors ARIAD. We will add five-initialization intervals for the 20/20 setting.

4. Under model mismatch the trajectory is decisive, and your L2 control shows it is not magnitude. White box is, by construction, the hardest test for the trajectory: as your W4 notes, the later states are recomputable there. In the realistic setting, where the attacker cannot run the victim exactly, the recorded states carry new evidence:

Black box, equal access (7B victim, 3B surrogate)Accuracy
Boundary (std.).524
Boundary (std.) + L2, best weight.552
ARIAD.765

The magnitude term closes only 2.8 of the 24.1-point gap. At equal cost, adding an anchor also beats three agreement-selected boundary restarts by +.068 [.058, .077] over three paired initializations, in less than half the time.

In summary, ARIAD clearly improves on the prior method even after tuning; its trajectory component significantly outperforms its own ablation in three of four white-box settings; the exact-match ties follow from the coverage limit both methods share; and under model mismatch the trajectory delivers a 24-point gain that an L2 term cannot reproduce. We hope this resolves the remaining concerns on W3–W4, and we would be grateful if you would reconsider your score in light of the full evidence.

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

The paper studies prompt reconstruction from observed hidden states of a language model. Building on PIA approach (Qu et al., 2025), the method additionally matches selected internal-layer states, chosen by a log-det criterion over self-generated token-substitution probes, and scores decoding candidates on the same layer. Experiments cover three domains, several model families and sizes, gray- and black-box settings, identifier recovery and activation defenses.

Critical strengths

The considered problem of stealing prompt information though hidden is important and understudied in AI security space. The particular case when an attacker has control over a machine partially hosting the model is a realistic scenario with huge security consequences. The experimental part provides careful statistical reporting with paired bootstrap intervals, an independent test after validation selection, and negative results reported openly.

Critical weaknesses
  1. The main paper’s motivation, and its differentiation on top of PIA’s paper is trajectory matching and hidden state analysis. However, it’s weakly supported. The most gains in the experiments seem to come from target standardization (section 5.2), which is not the main claimed contribution. On top of it, internal views, TAP placement and multi-view verification each add marginal accuracy (Table 4) and no EM gain over standardized boundary matching. The added cost of 45-50% per request is then loosely justified.

  2. Checking the supplementary material, several parts seems to be missing to reproduce the study: the permitted-target warm-up patch and the budget harness; black-box calibration code and gray-box LoRA/LRC code; learned baselines; identifier data and generators, plus the validation and independent-test prompts; the NERR implementation; geometric checks; any result logs.

  3. The paper appears hard to read. Key terms are used before or without definition: "target conditioning" (= the §3.3 standardization), "surrogate", "permitted vs. privileged planning", "views/anchors/depths", Q7D, "fixed triple".

Questions for authors
  1. Given that standardization accounts for most of the gain over PIA and that the internal states are recomputable from the boundary in white box, what does trajectory matching contribute beyond standardized boundary matching with compute-matched restarts? Please support this with a cumulative ablation.

  2. Could the authors provide artifacts necessary for the full reproducibility?

1 comment

We thank Reviewer for recognizing the importance of the threat and the care of our statistical reporting, and for the pointed question on what the trajectory adds beyond standardization; it reshaped how the paper presents its contribution.

W1 / Q1. Most gains come from standardization; the trajectory adds little over the standardized boundary; what does it add beyond compute-matched restarts?

We agree that standardization is the largest white-box factor, and the paper now says so in the abstract, introduction, and cumulative ablation (Table 3): pooled over 400 paired requests it adds +.2275 EM [.180, .275]. Each trajectory component adds a smaller accuracy gain whose interval excludes zero. The "no EM gain" reading rests on one initialization, where both methods reach .540. Every comparison with Boundary (std.), including those it wins:

SettingBoundary (std.)ARIADΔ [95% CI]Paper
White box, 5 inits: accuracy.9730.9806+.0076 [.0021, .0131]Tables 16–17
White box, 5 inits: EM.565.607+.041 [.011, .072]Tables 17–18
White box, 20/20 candidates: EM.660.720+.060Table 5
Black box, equal access: accuracy.524.765+.241Table 6
Phi-3.5, 3 inits: EM−.082 [−.136, −.033]Table 18
CMS, 3 inits: EM−.087 [−.156, −.018]Table 18

For Q1, we gave the boundary attack the extra cost as agreement-selected restarts:

Equal-cost settingBoundary restartsTrajectoryPaper
Black box, same time cap: accuracy.597 (3 restarts, 321 s).665 (dual endpoint, 134 s), +.068 [.058, .077]Table 36
White box, equal time: restart-budget EM.811 (2 starts, 223 s).851 (ARIAD, 4 starts, 220 s)Figure 9

The trajectory is not uniformly better, so Boundary (std.) stays a baseline in every table.

W2 / Q2. Missing reproduction artifacts. All are now in the supplement:

RequestedSupplement
Permitted-target warm-uppti.py --tap-mode self (now the default)
Budget harnessbudget.py
Black-box calibrationcalibrate_blackbox.py, data/blackbox_depth_map.json
Gray-box LoRA / LRCmake_graybox.py; pti.py --victim-lora / --lora-subspace
Learned baselinesbaselines.py
Identifier data and generatorcanary_generator.py, canary_eval.py, data/canary_*
Validation / test promptsmake_splits.py, data/airline_split_{val,test}.json
NERRmetrics.py --nerr
Geometric checksgeo_expand.py
Result logsper-request records (pti_details.jsonl, args.json) from every run
New controls (Tables 4–5)scripts/run_boundary_l2.sh, coverage_eval.py

metrics.py recomputes every reported metric from the per-request records.

W3. Terms used before they are defined. Each is now defined before first use and collected in Table 7 (Appendix A), and internal run labels are gone:

Original termRevisionDefined in
target conditioningtarget standardizationSec. 3.2, Eq. 4
views / depthsanchors: depths whose states the attack matchesSec. 2.2
surrogatesmaller public model run by a black-box attackerSec. 2.1
permitted vs. privileged planningequal-access vs. privileged planning (†)Sec. 5.1
Q7D and other run labelsremoved; the text names model and position in full—
fixed tripleboundary, middle-block output, last stateTable 7, Figure 7

We hope the cumulative ablation, the compute-matched comparisons, and the complete supplement resolve the soundness and reproducibility concerns, and we would be grateful if the reviewer would reconsider the rating in light of these revisions.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Overview of the rebuttal and the revision

We thank all three reviewers. The reviews converged on two themes: presentation, and what the trajectory adds beyond standardized boundary matching. We rewrote the paper around both. The main changes:

  1. A standalone threat model (Sec. 2.1) and a stage-by-stage PIA-vs-ARIAD table (Table 1), placed before any method detail.
  2. One clear set of final results. The 10-page body reports directly comparable results (Tables 2–6 and Figure 3). Diagnostic and correctness-only material moved to a condensed appendix (54 → 36 pages in total), with every table caption rewritten in plain language and five dense tables redrawn as figures.
  3. A cumulative ablation (Table 3) that attributes the gains component by component, together with the repeated-initialization results that settle the exact-match question.
  4. The two requested controls, now in the main body: an L2-at-boundary experiment (Table 4) and an all-methods candidate-budget comparison (Table 5). Both run from the released code.
  5. A complete reproduction suite in the supplement (table under h2N5-W2).

Sorry for the late rebuttal due to experiments. We sincerely hope reviewers can take time to have another look.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.