acceptodds
Under review as a conference paper at ICLR 2027

Grammar-Guided Code Watermarking with Green Temperature

Abstract

Large language model watermarking embeds detectable statistical signals during decoding, but the resulting changes to token probabilities can degrade generation quality. This trade-off is particularly important for code, where small changes in token selection can break syntax or alter program behavior. Existing code watermarking methods mitigate this risk through entropy-based insertion or syntax-aware token selection, but they do not directly construct the watermark over the set of continuations admitted by the current grammar state. We propose Grammar-Guided Code Watermarking with Green Temperature (GTCW), which integrates grammar-constrained decoding with probability-aware watermarking. At each decoding step, GTCW restricts the candidate set to grammar-admissible tokens and partitions this support into keyed green and red subsets. At eligible high-entropy positions, green temperature reweights the green tokens according to the model's relative preferences, strengthening the watermark signal while retaining the grammar constraint. Across five models and five benchmarks spanning four programming languages, GTCW achieves a mean AUROC of 73.61%, compared with 67.83% for the strongest baseline, while maintaining a mean Pass@1 of 59.18% versus 59.58% for unwatermarked generation. Our implementation is available at https://anonymous.4open.science/r/GTCW-Submission-4BBC/.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Code Generation, LLM Watermarking, Constrained Generation, Green Temperature

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_CaAEOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper introduces Grammar-Guided Code Watermarking with Green Temperature (GTCW) for code generation models. To prevent syntactic violations caused by standard vocabulary-wide partitioning, GTCW integrates context-free grammar parsing to constrain the watermark support strictly to admissible tokens. At eligible high-entropy positions, it employs green temperature scaling to sharpen green token logits according to the model's existing preferences rather than applying a uniform additive bias. The authors evaluate GTCW across five instruction-tuned models and five benchmarks covering Python, C++, Java, and Go, demonstrating improved detection metrics while maintaining functional correctness close to the base model.

Critical strengths

1.Restricting watermark candidate selection to grammar-admissible tokens provides a principled solution to mitigate syntax violations during code generation, with the ablation study clearly showing that grammar constraints preserve execution pass rates while green temperature enhances detection separability.

2.The empirical validation is comprehensive and well-designed, covering multiple model architectures, four programming languages, realistic code transformations, and dedicated evaluations conditioned on functionally correct outputs.

Critical weaknesses

1.The generation latency overhead is severe for practical deployment; token throughput drops from 65 tokens/s to 17.24 tokens/s, increasing completion time nearly threefold from 4.28s to 11.50s per snippet.

2.The detection procedure exhibits high operational dependencies and vulnerability under post-processing. It requires full white-box forward passes with the original model checkpoint to reconstruct the entropy gate, and the watermark appears fragile against semantic rewriting, with detection performance dropping to near random guessing (AUROC 51.4%, TPR@5% 6.8%) under LLM rewriting.

Questions for authors

1.Could the authors provide a detailed runtime breakdown for the 11.50s latency in Table 7 to clarify how much overhead stems from CFG state transitions versus logit reweighting, and whether standard structured decoding engines (e.g., XGrammar) could feasibly bridge this throughput gap?

2.In the replay algorithm, detection terminates upon the first parse error or inadmissible token; how sensitive is the detector to minor syntax modifications or typos that might occur early in the code snippet?

3.Since typical code generation pipelines sample at lower temperatures (e.g., T_0 = 0.2), how does green temperature behave when applied to an already peaked distribution?

2 comments

We thank the reviewer for recognizing the strengths of our approach and evaluation. We address the concerns below.

Q1. Generation Overhead and Optimization Potential

We profiled 164 HumanEval generations with Qwen2.5-Coder-3B-Instruct to separate model inference, grammar decoding, and watermarking costs.

Metric (ms/token)BaseGrammarOnlyGTCW
Model forward8.919.8810.02
Other generation0.4116.5928.90
Total generation9.3226.4738.92
With synchronization--49.4749.63

Grammar decoding accounts for substantial overhead, with additional costs from GTCW. However, fine-grained CUDA synchronization increases GrammarOnly and GTCW runtimes to 49.47 and 49.63 ms/token, nearly eliminating their gap. The instrumented entropy gating, green partitioning, and logit reweighting operations account for only ~0.58 ms/token. This suggests that GPU-CPU synchronization and execution serialization may contribute substantially to the observed overhead, although their precise contributions require further investigation.

Our implementation uses a custom Rust grammar engine without extensive runtime optimization. Potential improvements include reducing unnecessary GPU-CPU synchronization, optimizing GPU-side watermark operations, adopting efficient grammar engines and caching, and overlapping grammar processing with model inference, as explored in XGrammar (Dong et al., 2025). Since profiling uses a relatively small 3B model, grammar-related overhead may also be proportionally smaller for larger models. Our primary contribution is the watermarking mechanism rather than decoding-engine optimization.

Q2. Sensitivity to Syntax Modifications

Grammar replay can terminate upon encountering an inadmissible token, particularly when syntax-breaking modifications occur early in the generated code. We acknowledge this limitation. However, our primary setting is functional code generation, where syntactically invalid modifications generally compromise the intended functionality and therefore fall outside our main robustness threat model. In contrast, grammar-preserving modifications do not necessarily terminate replay, although they may still weaken watermark evidence. Our robustness evaluation focuses on code transformations that preserve executable functionality, rather than arbitrary syntax-breaking typos.

Q3. Behavior at Low Sampling Temperatures

GTCW, like other sampling-based watermarking methods, requires some uncertainty in token selection. Under nearly deterministic decoding, fewer alternative tokens are available for watermark insertion. We evaluated sampling temperatures of T0=0.2,0.5T_0 = 0.2, 0.5, and 1.01.0 on 164 HumanEval+ Python tasks using Qwen2.5-Coder-3B-Instruct. For GTCW, we maintained the temperature ratio Tg=T0/2T_g = T_0/2.

T0T_0MethodAUROC (%)TPR@5%FPR (%)Pass@1 (%)
0.2GTCW76.4950.0076.22
Best baseline66.67 (SWEET)20.73 (SWEET)78.05 (SWEET/STONE)
0.5GTCW75.6741.4674.39
Best baseline67.37 (SWEET)14.02 (KGW)76.22 (SWEET/STA-1)
1.0GTCW77.7543.2968.90
Best baseline70.46 (Unigram)23.17 (SWEET)70.12 (STA-1)

Even at T0=0.2T_0 = 0.2, GTCW achieves 76.49% AUROC and 50.00% TPR@5%FPR, outperforming the strongest existing baselines by 9.82 and 29.27 percentage points, respectively. Across all tested temperatures, GTCW consistently provides stronger detection while maintaining competitive Pass@1. These results suggest that green-temperature scaling remains effective even under sharply peaked token distributions.

W2. Detection Dependencies and Rewriting Robustness

We acknowledge that entropy-aware detection requires white-box access to the original model for forward-pass reconstruction. This introduces computational and deployment costs, although detection does not require autoregressive generation.

Regarding robustness, extensive LLM rewriting is a common limitation of existing token-level watermarking methods, not a vulnerability specific to GTCW. In our evaluation, rewriting reduces GTCW's AUROC to 51.4%, while competing methods similarly achieve near-chance performance (48.8–55.7%). Such attacks substantially alter token sequences and contexts, disrupting the statistical signals on which these methods rely.

However, GTCW performs relatively better under the other 12 code transformation settings, ranking first or second in TPR@5%FPR and achieving the highest average TPR of 27.2%. These results distinguish its relative effectiveness under localized transformations from its vulnerability to extensive rewriting.

AuthorsOpenReview ↗

Request for Discussion Engagement

Thank you for your time and constructive feedback. We have carefully addressed your concerns through detailed clarifications and additional experiments.

As the discussion period approaches its end, we would greatly appreciate it if you could review our responses and newly added results. In particular, we have:

  • Q1: Added a detailed runtime breakdown distinguishing grammar decoding from watermark computation and discussed potential optimizations.
  • Q2: Clarified the detector's sensitivity to syntax-breaking modifications and the limitations of grammar replay and white-box detection.
  • Q3: Conducted additional experiments at lower sampling temperatures, including 0.2, demonstrating that GTCW retains strong detectability under more peaked distributions.
  • W2: Further discussed rewriting robustness, distinguishing localized code transformations from extensive LLM rewriting.

We hope these clarifications and results adequately address your concerns. If you find our responses satisfactory, we would be grateful if you could reconsider your evaluation, including the overall score.

Please let us know if any concerns remain. We would be happy to address them.

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

This paper proposes Grammar-Guided Code Watermarking with Green Temperature (GTCW), a decoding-time watermarking method for code generation. GTCW constructs keyed green/red partitions over grammar-admissible tokens and applies a green-specific temperature transformation to strengthen watermark signals while preserving the model's token preferences. Experiments across five models and five benchmarks demonstrate improvements in watermark detectability with limited average degradation in functional correctness.

Critical strengths

The paper addresses an important problem: balancing watermark detectability and functional correctness in code generation.

The proposed integration of grammar-guided partitioning and green temperature is intuitive and technically interesting.

The experiments cover multiple models and programming languages, with consistent improvements in TPR@5%FPR. The ablation studies also provide useful evidence about the contributions of the two components.

Critical weaknesses

1 Novelty and missing closely related work.

The novelty relative to existing probability-aware watermarking methods is not sufficiently established. In particular, SSG (ACL 2026) and WaterMod (AAAI 2026) investigate limitations of random green/red partitioning by incorporating token probability information, including evaluations on code generation. These studies are closely related to GTCW's motivation of preserving model preferences while improving detectability.

Although GTCW employs different mechanisms, the paper should clarify its conceptual and technical distinctions from these approaches. Experimental comparisons with these methods would further strengthen the novelty claim.

  1. Fairness of baseline comparisons.

Appendix B.1 states that only GTCW uses grammar constraints in the main comparison. Consequently, the reported improvements may partly arise from grammar-constrained decoding rather than the proposed watermarking mechanism itself.

A grammar-only baseline and comparisons where existing watermarking methods use the same grammar constraints would help isolate GTCW's actual contribution. Furthermore, the baselines use fixed watermark strengths, whereas GTCW introduces a different reweighting parameter. Comparisons under matched Pass@1 degradation would provide stronger evidence of a superior detectability–quality trade-off.

  1. Insufficient theoretical justification for green temperature.

Equation (7) demonstrates that green temperature sharpens relative probabilities among green tokens. However, this does not necessarily imply an increase in the total probability mass assigned to the green set. Green tokens with logits below the anchor may instead be suppressed, potentially reducing watermark strength at some positions.

The authors should clarify under what conditions green temperature increases green-set probability mass and provide empirical analysis of this behavior.

  1. Statistical reliability and robustness.

The paper reports averages over three seeds without sufficient uncertainty estimates for the main comparisons. Additionally, the TPR@5%FPR thresholds are calibrated on the evaluated negative samples, leaving their generalization to independent samples unclear.

The robustness results also reveal substantial vulnerability to LLM rewriting, where GTCW's AUROC drops to 51.4%. Moreover, transformed outputs are compared against untransformed negative samples, and functional correctness is not re-evaluated after transformation. These limitations should be considered when interpreting robustness claims.

Questions for authors

How does GTCW compare with SSG and WaterMod, particularly under matched grammar constraints?

Does GTCW retain its advantages when all methods use the same grammar-constrained decoder and are compared at similar Pass@1 degradation?

Under what conditions does green temperature increase the total green-set probability mass?

How stable are the reported TPR@5%FPR improvements across independent calibration sets and different watermark keys?

2 comments

We thank the reviewer for the constructive feedback. We address the four concerns below.

W1. Novelty and additional baselines

GTCW differs from SSG and WaterMod in its underlying technical approach. SSG balances token logits across green/red partitions, and WaterMod uses token probability ranks. GTCW instead combines keyed partitioning of grammar-admissible tokens with green-specific temperature scaling to improve watermark detectability while preserving code functionality. We further evaluate SSG and WaterMod. All experiments use Qwen2.5-Coder-3B-Instruct on HumanEval+.

SSG achieves higher detection performance than GTCW, but GTCW retains higher Pass@1 than SSG. WaterMod exhibits near-chance detection in our evaluation. Its mean positive and negative scores are nearly identical, suggesting sensitivity to the model-generated negative distribution.

MethodCFGAUROCTPR@5%FPRPass@1
---:---:---:---:---:
BaseX——67.9
GrammarOnlyO——66.5
KGWX68.122.063.4
O68.220.165.2
SWEETX68.924.468.7
O69.823.269.5
UnigramX68.118.965.0
O70.613.465.9
STONEX63.311.267.1
O63.912.270.7
SSGX85.054.965.2
O84.854.364.6
WaterModX49.85.572.0
O49.75.572.0
GTCWO77.843.368.9

W2. Fairness of grammar constraints

Our original ablation studies already demonstrate that both grammar-guided partitioning and green temperature contribute to GTCW's improvements. Thus, the reported gains cannot be attributed solely to grammar-constrained decoding.

We further apply the same grammar constraints to baselines. As shown above, applying CFG generally yields modest improvements in Pass@1, but their detection performance remains below GTCW. Notably, applying CFG to SSG slightly decreases both detection performance and Pass@1. These results demonstrate that adding grammar constraints alone cannot reproduce the benefits of GTCW's combined design.

W3. Theoretical justification of green temperature

We agree with the reviewer's intuition that amplifying green-token logit deviations does not necessarily increase the total green probability mass. We have derived the exact change in green probability mass and identified the theoretical condition for its increase, characterized by a probability-weighted amplification factor R.

Intuitively, consider two green tokens with symmetric positive and negative logit deviations around the anchor. Doubling the logit deviations squares the corresponding unnormalized probability weights. Thus, exponential scaling produces a greater increase from above-anchor tokens than the corresponding decrease from symmetrically positioned below-anchor tokens, favoring an increase in total green probability mass.

We further validated this behavior using previously generated outputs. Across all 1,005 watermark-eligible decoding positions, the total green probability mass increased at every position, with an average absolute increase of 0.4884.

W4. Statistical reliability and robustness

We additionally report standard deviation across three generation seeds for the main experiments covering five models and five benchmarks.

MethodAUROC (%)TPR@5%FPR (%)Pass@1 (%)
Base——59.58 ± 0.38
Unigram67.33 ± 0.1018.66 ± 1.0755.00 ± 0.74
KGW67.83 ± 0.5320.64 ± 0.0455.40 ± 0.52
SWEET66.49 ± 0.2024.50 ± 0.2258.87 ± 0.62
STONE62.69 ± 0.2414.56 ± 0.3357.03 ± 0.17
STA-159.33 ± 0.4910.84 ± 0.6259.08 ± 0.57
GTCW73.61 ± 0.2841.86 ± 0.6059.18 ± 0.62

We examined key sensitivity using three distinct secret keys on 164 HumanEval tasks. AUROC was 76.15 ± 1.48%, while TPR@5%FPR was 43.90 ± 8.25% (mean ± sample std), indicating stable AUROC but greater variation in TPR across keys.

We also evaluated threshold generalization through task-disjoint five-fold calibration on HumanEval and MBPP. In each fold, thresholds were calibrated at 5% FPR using Base scores from four folds and evaluated on held-out Base and GTCW outputs. The average held-out FPR and TPR were 4.47% and 48.17% on HumanEval, and 4.67% and 83.60% on MBPP, respectively. Cross-dataset calibration revealed sensitivity to distribution shifts, with FPRs of 5.29–11.11% for HumanEval-to-MBPP and 1.22–3.66% for MBPP-to-HumanEval.

Regarding robustness, GTCW performs relatively better than existing methods under several code transformations, but we do not claim general robustness. Our rewriting evaluation uses unmodified negative samples, a potentially more favorable setting for detection. We additionally evaluated the functionality of LLM-rewritten outputs. The results showed that 109/113 originally correct outputs remained correct after rewriting, while 33 incorrect outputs became correct.

AuthorsOpenReview ↗

Request for Discussion Engagement

Thank you for your time and constructive feedback. We have carefully addressed your concerns through detailed clarifications and additional experiments.

As the discussion period approaches its end, we would greatly appreciate it if you could review our responses and newly added results. In particular, we have:

  • W1: Clarified GTCW's distinctions from SSG and WaterMod and added experimental comparisons with both methods.
  • W2: Evaluated existing watermarking baselines under identical grammar constraints to better isolate GTCW's contributions.
  • W3: Derived the theoretical condition under which green temperature increases total green probability mass and empirically verified this behavior across 1,005 eligible decoding positions.
  • W4: Added uncertainty estimates, key-sensitivity experiments, independent threshold calibration analyses, and functional correctness evaluations after LLM rewriting.

We hope these clarifications and results adequately address your concerns. If you find our responses satisfactory, we would be grateful if you could reconsider your evaluation, including the overall score.

Please let us know if any concerns remain. We would be happy to address them.

Reviewer_sjG8OpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes GTCW, a grammar-guided watermarking method for LLM-generated code. It combines grammar-constrained decoding with a green-temperature mechanism to strengthen watermark detection while preserving code correctness. Experiments across five models and four programming languages show improved detection over existing watermarking methods, with little change in average Pass@1.

Critical strengths

The paper addresses an interesting problem, and combining grammar constraints with probability-aware watermarking is a reasonable approach. The evaluation covers multiple models, languages, and benchmarks. I particularly appreciate the ablation study, which helps explain the contributions of grammar guidance and green temperature. The improvements in detection are encouraging.

Critical weaknesses

My main concern is the substantial runtime overhead. Appendix C.3 reports that GTCW reduces generation throughput from around 65 to 17 tokens per second, making it nearly four times slower than the baselines. This is a significant limitation for practical use, but the paper provides little analysis of where this overhead comes from or how much can be reduced.

Another concern is the fairness of the comparison. Only GTCW uses grammar-constrained decoding in the main experiments. It would be useful to compare against existing watermarking methods combined with the same grammar constraints to better isolate the contribution of green temperature.

Finally, the watermark remains vulnerable to code modifications. Table 4 shows that detection after LLM rewriting drops to an AUROC of 51.4%, close to random guessing. Since generated code is commonly modified during software development, this raises questions about the practical usefulness of the method. The finite-score coverage of around 74% is another limitation.

Questions for authors

What causes the substantial generation overhead? How much comes from grammar-constrained decoding versus watermark computation?

How does GTCW compare with existing watermarking methods when all methods use the same grammar constraints?

Can the authors improve detection after code rewriting? How much rewriting is needed to remove the watermark?

How does the method perform on longer, more complex code generation tasks beyond the evaluated benchmarks?

2 comments

We thank the reviewer for acknowledging the experimental strengths of our work. We address the four concerns below.

Q1. Generation Overhead and Optimization Potential

We profiled 164 HumanEval generations with Qwen2.5-Coder-3B to separate model inference, grammar decoding, and watermarking costs.

Metric (ms/token)BaseGrammarOnlyGTCW
Model forward8.919.8810.02
Other generation0.4116.5928.90
Total generation9.3226.4738.92
With synchronization--49.4749.63

Grammar decoding accounts for substantial overhead, with additional costs from GTCW. However, fine-grained CUDA synchronization nearly eliminates the runtime gap between GrammarOnly and GTCW (49.47 vs. 49.63 ms/token). The instrumented entropy gating, green partitioning, and logit reweighting operations account for only up to 0.58 ms/token. This suggests that synchronization and execution serialization may contribute substantially to the observed overhead.

Potential optimizations include reducing unnecessary GPU-CPU synchronization, moving watermark operations to the GPU, adopting efficient grammar engines and caching, and overlapping grammar processing with model inference, as explored in prior work such as XGrammar (Dong et al., 2025). Since our profiling uses a 3B model, the relative grammar processing overhead may also decrease for larger models with expensive forward passes.

Q2. Fair Comparison Under Identical Grammar Constraints

We applied GTCW's grammar constraints to KGW, SWEET, Unigram, and STONE while preserving their watermarking mechanisms and detectors. All experiments use Qwen2.5-Coder-3B-Instruct on 164 HumanEval+ Python problems.

MethodCFGAUROC (%)TPR@5%FPR (%)Pass@1 (%)
BaseX——67.90
GrammarOnlyO——66.46
KGWX68.1022.0063.40
KGWO68.1620.1265.24
SWEETX68.9024.4068.70
SWEETO69.8223.1769.51
UnigramX68.1018.9065.00
UnigramO70.6313.4165.85
STONEX63.3011.2067.10
STONEO63.8512.2070.73
GTCWO77.7543.2968.90

CFG generally improves Pass@1 but does not consistently improve detection. GTCW achieves higher AUROC (77.75%) and TPR@5%FPR (43.29%) than all four CFG-controlled baselines while maintaining 68.90% Pass@1. These results, together with our original ablations, indicate that grammar constraints alone cannot explain GTCW's improvements. Its combined grammar-guided partitioning and green-temperature reweighting are important.

Q3. Robustness to Code Rewriting and Detection Coverage

We acknowledge that LLM rewriting substantially reduces GTCW's detection performance. However, this limitation is not unique to our method. Extensive rewriting changes both tokens and their surrounding contexts, posing a common challenge to watermarking methods that reconstruct signals from token sequences. Prior studies have also demonstrated vulnerabilities of existing watermarking approaches to paraphrasing and semantics-preserving code transformations (Rastogi and Pruthi, 2024; Zhang et al., 2026).

In contrast, GTCW remains competitive under more localized code transformations. Under the other 12 code transformation settings, GTCW ranks first or second in TPR@5%FPR and achieves the highest average TPR (27.2%). This suggests relatively better robustness to these transformations, rather than general resistance to rewriting attacks.

We explicitly discussed detection coverage in the original paper. GTCW's finite-score coverage reflects entropy-based token eligibility and additional grammar-replay requirements. This limitation arises particularly in short, low-entropy code, where highly probable tokens offer few opportunities for watermark insertion, or in malformed code where grammar replay fails. Importantly, GTCW still outperforms the original baselines in overall detection, making limited coverage a reasonable trade-off.

Q4. Evaluation on Longer and More Complex Code Generation

We evaluated 165 CodeContests Python problems using Gemma 4 12B Instruct with up to 8,192 generated tokens, comparing GTCW with Base.

MethodAUROC (%)TPR@5%FPR (%)Pass@1 (%)
Base——40.00
GTCW98.7698.7948.48

GTCW achieved 98.76% AUROC and 98.79% TPR@5%FPR, demonstrating strong detectability on longer code generations. Longer outputs provide more opportunities for watermark insertion, consistent with the high detection coverage of 98.79%. Notably, GTCW also achieved higher Pass@1 (48.48%) than Base (40.00%), alongside higher syntax validity (93.33% versus 80.00%), suggesting its scalability to longer code generation.

AuthorsOpenReview ↗

Request for Discussion Engagement

Thank you for your time and constructive feedback. We have carefully addressed your concerns through detailed analyses and additional experiments.

As the discussion period approaches its end, we would greatly appreciate it if you could review our responses and newly added results. In particular, we have:

  • Q1: Added a detailed runtime breakdown separating model inference, grammar decoding, and watermarking overhead, and discussed potential optimizations.
  • Q2: Evaluated existing watermarking baselines under identical grammar constraints to provide a fairer comparison.
  • Q3: Clarified the limitations under LLM rewriting, analyzed robustness under other code transformations, and discussed finite-score detection coverage.
  • Q4: Extended the evaluation to longer CodeContests problems with up to 8,192 generated tokens, demonstrating strong detectability and competitive functional correctness.

We hope these clarifications and results adequately address your concerns. If you find our responses satisfactory, we would be grateful if you could reconsider your evaluation, including the overall score.

Please let us know if any concerns remain. We would be happy to address them.

Comments on the paper

1 comment

We thank the reviewers for their constructive feedback. We have revised the manuscript to clarify our methodological contributions, theoretical justification, and practical limitations. We expanded comparisons with recent watermarking methods, including SSG and WaterMod, and evaluated existing baselines under matched grammar constraints. We also added theoretical and empirical analyses of green probability mass, detailed runtime breakdowns, statistical reliability and threshold calibration experiments, and evaluations under lower sampling temperatures and longer code generation tasks. Furthermore, we clarified the limitations of detection under code transformations and evaluated functional correctness after LLM rewriting. All revisions are highlighted in blue in the updated manuscript for ease of reference.

Furthermore, we want to emphasize that extensive LLM rewriting remains a shared limitation of existing token-level watermarking methods rather than a vulnerability specific to GTCW. Nevertheless, GTCW achieves strong watermark detectability while maintaining competitive Pass@1 across diverse code generation benchmarks, demonstrating an effective balance between detection performance and functional correctness.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.