acceptodds
Withdrawn from ICLR 2027

When Becomes : Prior-Induced Literal Override in Competitive-Programming Code Generation

Withdrawn from ICLR 2027, so left out of the paper lists and the map.

Abstract

Competitive-programming constraints determine which algorithms are computationally feasible. We study a specification-faithfulness failure in which an authoritative decimal literal also resembles a fused power-of-ten expression: is the integer 105 but also the surface left by deleting the exponent marker from . We call this prior-induced literal override. The corruption itself already appears at scale in CodeContests-O: among 11,683 problem descriptions, 3,008 (25.75%) contain at least one studied fused surface, and the matched occurrences were verified as exponent-loss cases rather than intended decimals. Holding the critical digits fixed, we vary semantic context and pair every collision with a same-length non-collision control. Across four open-weight models, attractor share is effectively zero in neutral copying but rises to 74.5% in full problem statements; unprompted greedy override reaches 64.3%. Direct literal disambiguation reduces attraction by about 50–52 percentage points, whereas generic self-verification has little effect. Across ten competitive-programming problems and six frontier code models, the collision surface lowers executable performance relative to literal-scale controls and often shifts generated programs toward the regime induced by an explicit constraint. Supporting probability, tokenization, and residual-stream analyses connect the shift to the literal–attractor competition. The failure is not repair itself, but failure to condition repair on source authority.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Large Language Models, Code Generation, Competitive Programming, Specification Faithfulness, LLM Robustness

Reviews

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

This paper studies prior-induced literal override in competitive-programming prompts, where a model reads an authoritative decimal bound such as 105 as the power of ten 10^5 that the same digits would form after exponent loss. Using seven collision-control pairs across seven contexts on four open-weight models, it shows that the attractor share rises from near zero in neutral copying to 74.5% in full problem statements. On ten scale-sensitive problems with six frontier models, the 105 surface lowers executable accuracy relative to the 100 and 145 controls, with supporting tokenization, probability, and activation-patching analyses.

Critical strengths
  1. The controlled design is careful. For example, the digit string is fixed, each collision has a same-length matched control, and the difference-in-differences analysis is validated with free generation.

  2. The corpus audit showing exponent-loss corruption in 25.75% of CodeContests-O descriptions is a useful data-quality finding on its own.

Critical weaknesses
  1. The paper studies only one specific case. Section 3.1 gives a general definition of notation collision, but the experiments instantiate a single transformation on seven power-of-ten strings in one domain, so the evidence does not support a general class of failure.

  2. The paper has no clear contribution on how to avoid the misinterpretation. The only reliably effective intervention is explicit disambiguation, which requires knowing in advance which number is ambiguous and telling the model directly, and the other interventions are inconsistent across models.

Questions for authors
  1. Does the effect hold for other instances of the Section 3.1 definition, such as subscript loss, other bases (2^10 written as 210), composite forms (10^9+7 written as 109+7), or domains outside competitive programming?

  2. Is there a mitigation that does not require identifying the colliding literal in advance? The collision-agnostic instructions in Table 17 change attraction in opposite directions for different models.

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

The paper studies prior-induced literal override. In competitive-programming, a decimal literal such as 105 can also be read as 10510^5. The paper audits 11682 CodeContests-O descriptions and find that 25.75% contain at least one such fused term, which they denote as verified exponent-loss. This collision often obscures the boundary and cause model to act towards the 10510^5 resource limit even though only numbers like 105 or 104 are mentioned.

Critical strengths
  • The paper has carefully controlled design to back up the explanations. The experiments try to separate the actual context-induced reinterpretation from copying or parsing failures by digit/length/attractor surface controls.
  • The paper shows verifiable consequences through execution.
Critical weaknesses
  • There are several conflicting evidence against the failure framing. In CodeContests-O 10^5 appears very often but 105 very rarely exists. Thus the problem may simply because of the bias in the dataset, which the paper does not effectively validate. Additionally, the paper defines the lossy-source regime but never evaluated it, which does not support enough the abstract and L482 claim of condition repair.
  • The paper uses a small, constructed evidence base, including using only 7 collision items for RQ1 and 2, 10 problems for RQ3. Additionally, the llm judge and verification in the paper is not properly described or human-calibered.
Questions for authors
  • How were the 3,008 corpus matches verified as exponent-loss? Did you find any genuine literal bounds of 104–109 or 1018?
  • App. D says the RQ2 baseline is byte-for-byte identical to RQ1, yet some per-model baselines differ (like gpt-oss short). There are also differences between table 2 and table 4. What explains these differences?
  • Has the LLM-judge solution-family audit (Table 24) been validated against human labels? Is the same-family judge biased when grading that family's model?
  • What are the "restricted semantic-foil probabilities" in Table 14?
Reviewer_icDZOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper studies models reading the decimal 105 as 10^5 in programming problems. Matched prompts, free generation, code execution, and activation tests connect this reading change to different algorithm choices. Explicit literal instructions reduce the effect.

Critical strengths
  • Keeping the digits fixed while changing context shows that the problem is interpretation, not simply failure to copy a number.
  • The code tests connect the wrong reading to algorithm choices and executable failures, giving the finding practical meaning.
  • Literal instructions work better than generic self-checking, giving a concrete lesson for writing reliable code prompts.
Critical weaknesses
  • The study treats the displayed decimal as authoritative. It does not test a mixed setting where some inputs need exponent repair and others must remain literal, so the rule for choosing between them remains open.
  • The ten code tasks are chosen so that 100000 rules out known practical exact solutions. This exposes the failure clearly, but is less representative of tasks where both readings allow valid algorithms.
  • The corpus audit finds lost exponent markers, where repair is appropriate. It establishes a real source of ambiguity, but not how often models wrongly override genuine decimal bounds in practice.
  • Figure 1 appears to generated using an AI image generation tool. For a figure as central as this one, a carefully crafted diagram would more effectively convey the technical substance of the work and inspire greater confidence in the paper's overall quality and contributions.
Questions for authors

Please respond to the concerns raised in Critical Weaknesses.

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

Related papers

Discussion (0)

Sign in to comment.