{"id":"921c4846-0f1e-4652-aea1-ed16c30fd71e","arxiv_id":"2505.04955","paper_version":1,"verdict":"CONDITIONAL","confidence":"HIGH","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":2,"one_line_summary":"Chain-of-thought tokens in a fine-tuned 1.5B language model behave like program variables: they store intermediate values, can be replaced by latent vectors without loss, and intervening on their values causally changes the output.","lead":"This paper tests whether chain-of-thought tokens in language models act like variables in a computer program, storing intermediate results that later steps read. On multi-digit multiplication and dynamic programming, keeping only the intermediate numbers works as well as full reasoning text, and changing those numbers changes the final answer.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Latent-token experiments never intervene on latent values, so 'form does not matter' could be an artifact of the model ignoring latent tokens.","rationale":"The paper's central analogy has two pillars: (i) value-bearing tokens are causally used, and (ii) the storage form is irrelevant. The intervention evidence for (i) is strong for explicit text CoT, but it is never extended to latent CoT. Section 3.3 compares task accuracy between explicit and latent CoT; high accuracy is consistent with the model using the latent values, but it is also consistent with the model ignoring the latent embeddings entirely and using the fixed-length sequence of <LAT> tokens as a scratchpad to recompute the DP from the input. The latent loss only forces the model to output the correct next latent value; it does not force the model to consume the previous latent value. Since all latent tokens share the same surface form, the model can rely on position and its own hidden state. The intervention experiment in Section 4.1 changes text numbers and observes downstream changes, but no analogous experiment changes a latent embedding. Therefore the strongest support for 'form does not matter' is missing exactly where the form is most different. The reader's weakest-assumption concern about linear probes in Section 4.2 is valid but secondary: even if probe accuracy were a faithful measure, it would only establish that the model can compute/write the next latent value, not that an external reader of that value uses it as a variable. The complexity-limit conclusion inherits the same gap. A single experiment, latent-embedding intervention, would settle both: if changing DP[i][j]'s latent value changes later latent values and the final answer as simulated, the latent values are causal variables; if not, the paper's latent-form claim reduces to 'identical placeholder tokens are enough,' which is a different and weaker statement. This is not a reason to reject the paper outright: the explicit-CoT evidence and error analysis are valuable, and the missing experiment is straightforward. The reader's CONDITIONAL verdict remains appropriate.","tokens_in":14382,"tokens_out":10448,"duration_ms":97339,"concrete_test":"Train/finetune the latent-token DP model as in Section 3.3. At inference, take a correct latent CoT prefix, modify the one-hot embedding of one intermediate <LAT> token (e.g., DP[i][j]) to a value that differs from the true value but stays in range, truncate the rest of the CoT, and let the model continue generating. Compare the subsequently generated latent values and final answer with a simulation using the modified value, exactly as the authors did for text CoT in Section 4.1 and Appendix E. Repeat on about 1000 examples from the 5x5 DP test set. If the final answer follows the modified value at a rate comparable to the 74% text-intervention success rate, the latent values are causally used and the concern is resolved.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The load-bearing gap is in Section 3.3: the latent-token experiments show that replacing some explicit intermediate values with one-hot latent tokens preserves task accuracy, but they never show that the model actually reads or uses those latent values. For multiplication (Figure 15) explicit partial results such as '|59451' remain in the latent CoT, so the only fully latent setting is DP. The intervention experiment in Section 4.1 is performed only on explicit text CoT; no equivalent intervention is done on latent embeddings. Under the paper's own framing, 'form does not matter' requires that the values are still causally used when stored in latent form. An alternative explanation is that the model treats the identical <LAT> tokens as scratchpad/pause tokens, recomputes the DP recurrence from the input grid at each step, and never consults the latent embeddings; accuracy would then be high while the latent values are causally inert. The linear probes in Section 4.2 do not resolve this: probe accuracy shows the values are decodable from hidden states, but that does not establish that an altered input latent value would be used. The computational-complexity conclusion in Section 4.2 inherits the same gap. The abstract's central claim ('storing intermediate results in an alternative latent form will not affect model performance') is only meaningful if the latent values are the causal carriers.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes that chain-of-thought (CoT) tokens in LLMs function like computer program variables: they store intermediate values that are used in subsequent reasoning steps, and the explicit textual form of storage is not essential. The authors study two synthetic compositional tasks, multi-digit multiplication and dynamic programming, using Qwen-2.5-1.5B fine-tuned with CoT. They report four main findings: (1) CoT is necessary for these tasks; (2) removing non-result tokens from CoT preserves most accuracy; (3) replacing explicit intermediate results with latent one-hot tokens does not substantially hurt performance; and (4) interventions on explicit CoT token values causally affect subsequent tokens and final answers, though sometimes shortcuts prevent the expected effect. The paper also claims a computational complexity limit between CoT tokens, supported by linear probe accuracy on hidden states when adjacent latent tokens are merged. The authors conclude that CoT tokens are like program variables, with implications for CoT compression and understanding latent reasoning.","tokens_in":14589,"tokens_out":2759,"duration_ms":29326,"significance":"If the main claims hold, the paper offers a useful empirical characterization of CoT: intermediate-value storage, not surface form, is what matters, and CoT can be compressed to value-carrying tokens without loss. The intervention experiments on explicit CoT are a concrete step beyond correlational analyses, and the error taxonomy for failed interventions (shortcut, addition, reconstruction, copy, misc) is a useful contribution. The paper also releases code and data, and its claims are framed as falsifiable empirical hypotheses. The central limitation is that the latent-token results stop short of showing that the latent values are actually read and used by the model, which is the load-bearing step for the 'form does not matter' and 'variables' conclusions. The computational-complexity claim in Section 4.2 likewise rests on linear probe accuracy, which cannot by itself distinguish inability to compute from non-linear encoding. These gaps, together with the absence of error bars and the single-model/single-seed setup, currently prevent the strong conclusions from being fully supported.","major_comments":[{"comment":"The latent-token experiments show that replacing intermediate values with one-hot latent vectors preserves accuracy, but they never demonstrate that the model actually reads or uses the latent values. For DP, the CoT in Figure 16 contains only identical-looking <|fim_middle|> tokens; the model could plausibly treat them as pause/scratchpad tokens and recompute the DP recurrence from the input grid at each step, ignoring the latent embeddings entirely. The intervention experiments in Section 4.1 are performed only on explicit text CoT, and the linear probes in Section 4.2 show decodability, not causal use. Without an intervention on the latent embeddings (e.g., flipping a digit in the one-hot vector and observing a corresponding change in downstream computation), the claim that 'storing intermediate results in an alternative latent form will not affect model performance' is not established; the alternative explanation that the latent vectors are causally inert is not ruled out.","section":"Section 3.3, Figures 4, 15, 16"},{"comment":"The computational-complexity-limit conclusion relies entirely on linear probe accuracy on the previous token's hidden state. Low probe accuracy could reflect a non-linear encoding that the model still uses successfully, rather than an inability to compute the next intermediate variable. The paper does not report a non-linear probe baseline, a control on a setting where the value is known to be used, or any intervention that connects probe accuracy to downstream behavior. As stated, the claim that 'there exists a computation complexity limit, over which the LLM can no longer correctly calculate the next intermediate variable' is an overinterpretation of Figure 8; the figure would need to be accompanied by a causal or at least a controlled representational test.","section":"Section 4.2, Equation 5, Figure 8"},{"comment":"The claim that 'preserving only tokens that store intermediate results would achieve comparable performance' is tested only on multiplication; no compressed-CoT experiment is reported for dynamic programming. Since the paper's abstract and conclusion generalize across both tasks, the missing DP condition leaves the generalization unsubstantiated. Additionally, the latent-form claim already shows a 9% accuracy drop on 4x5 DP (Figure 4b), which complicates the statement that 'storing intermediate results in an alternative latent form will not affect model performance' and should be discussed as a meaningful exception or as evidence of a limit, not just as motivation for Section 4.2.","section":"Section 3.2 and Figure 2"},{"comment":"No error bars, confidence intervals, or multiple seeds are reported anywhere in the paper. All experiments use a single fine-tuned model of one size (Qwen-2.5-1.5B), and the conclusions about 'comparable performance' and 'almost identical' accuracy depend on differences that could be within run-to-run variance. At minimum, the authors should report the number of seeds, the variance across seeds, and preferably statistical tests for the key comparisons in Figures 2, 4, and 6. Without this, the empirical support for the central claims is difficult to evaluate.","section":"Section 3 and all figures"}],"minor_comments":[{"comment":"The phrase 'under multinominal complexity' should be 'under polynomial complexity'.","section":"Section 1"},{"comment":"The phrase 'to compress consequent number digits' should be 'to compress consecutive number digits'.","section":"Section 3.3, first paragraph"},{"comment":"The footnote describing which tokens are removed is incomplete: it says 'see Appendix C for details,' but Appendix C (Main Experiment Settings) does not contain such details; the actual removal procedure appears in Appendix A. Please fix the cross-reference.","section":"Section 3.2, footnote 1"},{"comment":"The axes of Figure 9 are labeled 'Digit Scale' and 'Accuracy Breakdown,' but the caption and text refer to digit lengths and accuracy values; please clarify the exact quantities plotted and whether 'token accuracy' in this figure refers to the merged latent tokens.","section":"Section 4.2, Figure 9"},{"comment":"The intervention error breakdown reports 1291 shortcut errors out of 2616 errors, but the category definitions in Section 4.1 mention 'Copy error' and 'Misc error' with different percentages in Figure 6b; please ensure the figure and table are consistent.","section":"Appendix E, Table 1"},{"comment":"The one-hot encoding formula uses 10n dimensions for an n-digit number, and the text says d=20 for multiplication (digit plus carry) and d=50 for DP. Please clarify whether this means DP values are restricted to at most 5 digits, and note that the DP input values are bounded below 100, so the DP latent tokens store substantially larger numbers than the inputs.","section":"Section 3.3, Equation (1)"}],"recommendation":"major_revision","confidential_remarks":"The paper addresses an interesting and timely question, and the intervention-on-explicit-CoT part is a genuine empirical contribution. However, the latent-token experiments currently stop short of the paper's strongest claim: they do not show that the latent values are causally used. The complexity-limit conclusion is also built on linear-probe evidence without the necessary controls. These gaps are fixable with additional experiments (latent-value interventions, non-linear probe or control conditions, multi-seed runs), which is why I recommend major revision rather than rejection. I would also encourage the editor to require the authors to address the missing compressed-CoT condition for DP, because the current abstract overgeneralizes from the multiplication experiment."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Colleague,\n\nThe short version: this paper is worth engaging with. It argues, with experiments, that CoT tokens work like program variables — they store intermediate values that later steps actually use. The strongest evidence is the intervention study: change a value in a generated multiplication CoT and the subsequent reasoning and final answer change accordingly, with a sensible error taxonomy. The token-pruning result (keep only the numbers, drop the words) is also clean and, on multiplication, convincing.\n\nThe latent-token experiment is the mixed part. Replacing intermediate text with one-hot latent tokens and adding a projection/head is a creative design, and performance holds up on multiplication and mostly on DP. But the paper never intervenes on the latent values themselves. You can't rule out that the model is using its hidden states as scratchpad and treating the <LAT> tokens as placeholders. The architecture does feed the predicted latent embedding back as the next input, so the \"values are never consulted\" alternative is not fully credible, but the causal role of the latent values is inferred, not demonstrated. That's a fixable gap, but it's real.\n\nThe weakest section is 4.2. The \"computational complexity limit\" is based entirely on linear probe accuracy dropping when adjacent latent tokens are merged. The paper does not report task accuracy for the merged setting, and low linear probe accuracy can simply mean the encoding became nonlinear. The claim that \"the LLM can no longer correctly calculate the next intermediate variable\" does not follow from the probe numbers. This is the load-bearing issue for the complexity-limit part of the abstract, and I side with the reader's concern there.\n\nOther soft spots, in order: one 1.5B model, no seeds or error bars anywhere; the compressed-CoT experiment exists only for multiplication, while the abstract generalizes; and the latent-form claim rests on a single one-hot encoding scheme. These are all addressable with extra experiments, which is why the paper is conditional rather than broken.\n\nThe paper is honest about its own limits — it says outright that it lacks a theoretical proof and that only synthetic tasks are used. Citation practice is fine; the only self-citation supports a peripheral point. Code and data are available.\n\nWho is this for? People working on CoT compression, latent reasoning, or mechanistic interpretability of intermediate steps. The variable framing is a genuinely useful lens even if the current evidence is narrower than the abstract suggests. I'd accept it for peer review — a good referee will push on 4.2 and the latent intervention, and those are precisely the parts that can be strengthened. I would not desk reject it.","headline":"A useful empirical study of CoT as variable storage, with strong intervention evidence on explicit tokens and a weaker, probe-based complexity claim.","tokens_in":15167,"tokens_out":6167,"would_cite":true,"duration_ms":62702,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"Chain-of-thought tokens store and reuse values like program variables","keywords":["chain-of-thought","program variables","intermediate values","latent tokens","causal intervention","multi-digit multiplication","dynamic programming","linear probing"],"falsifier":"For the 5x5 dynamic-programming task with merged latent tokens, replace the linear probes with a nonlinear classifier and also measure final-answer accuracy directly; if the model's final accuracy stays high while linear-probe accuracy falls to near zero, the claimed complexity limit is a probe artifact rather than a real processing bound.","tokens_in":14097,"feed_emoji":"🧮","tokens_out":6371,"duration_ms":56929,"temperature":0.7,"pith_summary":"The paper argues that the intermediate tokens generated during chain-of-thought reasoning act like variables in a computer program: their main job is to store partial results that later reasoning steps read, rather than to present a readable argument. On two tasks that demand serial computation, multi-digit multiplication and dynamic programming, the authors show that a model fine-tuned to generate only the numeric intermediate values performs about as well as with the full textual steps, and that compressing those values into single latent vectors barely hurts accuracy. They also show that randomly overwriting an intermediate value changes the subsequent tokens and the final answer, exactly as a mutable program variable would. The paper concludes that CoT works because it forces the model to materialize and reuse intermediate values, but that this mechanism has limits: too much compression or too large a computational gap between values breaks the computation. If right, this means CoT can be compressed to just the essential value tokens, and that explicit text reasoning and latent-space 'thinking' may rely on the same underlying variable-storage mechanism.","feed_headline":"CoT tokens act as program variables, storing reused values","feed_subtitle":"Removing all but value tokens keeps accuracy; latent tokens work too, so form matters less than content.","key_machinery":"The experimental machinery is a controlled comparison across four forms of the same reasoning trace: full textual CoT, a variables-only CoT with all non-numeric tokens removed, a latent CoT where intermediate numbers are encoded as single one-hot vectors fed through a linear input projection with a matching latent output head, and an intervened CoT where one stored value is randomly replaced and the rest of the trace is regenerated. The first three forms isolate whether the value or the form carries the computation; the fourth tests causality. A final linear-probing setup reads the value of the next latent token from the previous token's hidden states at every layer, giving a per-layer measure of when the next variable is actually computed.","core_discovery":"The central discovery is that the tokens in a chain of thought store intermediate numerical values that are subsequently read by the model, and the linguistic form of those tokens is not what matters. On both tasks, deleting all non-numeric tokens from the CoT leaves accuracy essentially unchanged, and replacing a group of digit tokens with a single latent token that encodes the same number also preserves performance, as long as the number is small enough. Interventions, randomly changing a carry, a partial product, or a dynamic-programming cell, propagate to later tokens and to the final answer, matching variable-update semantics. The paper also finds that the model sometimes learns shortcuts, such as copying a multiplicand when multiplying by 1, that leave some variables unused; and that when two computations are merged into one step, linear probing cannot recover the value of the next variable, indicating a computational-complexity limit on how much a single token can be asked to compute.","pith_inferences":["If the variable view is right, the benefit of CoT on hard problems may come from forcing the model to commit intermediate results to memory, which could explain why longer CoT and even filler tokens help: they add more 'register' space for variable storage.","The one-hot latent representation is a minimal test of form independence; a richer continuous latent space might allow even more compression or might fail in different ways, depending on the model's capacity.","The computational-complexity limit may be scale-dependent: larger models with more layers or wider hidden states might tolerate more aggressive merging, turning the claimed limit into a capacity bound rather than a fundamental one.","Intervention success rates could serve as a diagnostic for which tokens a model actually relies on, complementing the paper's error taxonomy and offering a way to detect unfaithful reasoning."],"forward_implications":["CoT can be compressed to tokens that store intermediate values without significant accuracy loss, suggesting more efficient inference paths.","Because the storage form does not matter, latent-space reasoning and textual chain-of-thought may share the same variable-storage mechanism, connecting explicit and implicit CoT methods.","Intermediate values can be edited directly, so a model's output can be steered by rewriting a single variable in its chain of thought, which may enable controllable generation or error correction.","The observed computational-complexity limit implies a bound on how much work a single CoT token can encapsulate, which should inform token design and model architecture choices.","Shortcut behaviors, where the model ignores variables in easy subproblems, show that generated reasoning traces are not always faithful to the actual computation being performed."],"supporting_citations":[{"why":"Introduces chain-of-thought prompting and supplies the baseline effectiveness that the paper builds on.","marker":"Wei et al., 2022"},{"why":"Theoretical result that CoT helps transformers solve inherently serial problems, motivating the choice of multiplication and dynamic programming tasks.","marker":"Li et al., 2024"},{"why":"Shows latent-space reasoning can work, which the paper extends by demonstrating that latent tokens can store intermediate values.","marker":"Hao et al., 2024"},{"why":"Documents limits of transformers on compositionality and describes shortcut behavior that explains the intervention failures observed here.","marker":"Dziri et al., 2023"},{"why":"Provides causal mediation analysis of arithmetic reasoning, informing the intervention methodology used in Section 4.1.","marker":"Stolfo et al., 2023"},{"why":"Shows that language models encode number values linearly, supporting the use of linear probes on intermediate values in Section 4.2.","marker":"Zhu et al., 2025"},{"why":"Theoretical limitations of multi-layer transformers that frame the discussion of a computational-complexity limit between tokens.","marker":"Chen et al., 2024"}],"fun_headline_variants":["CoT tokens are variables, not just text","LLM reasoning tokens store values like code","Deleting non-value CoT tokens keeps accuracy","CoT token content, not form, drives answers","Chain-of-thought tokens act as program variables"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The claimed computational-complexity limit assumes that a linear probe on the previous token's hidden state accurately measures whether the model can compute the next intermediate value; if the value is stored nonlinearly, the probe could report failure even when the model computes it fine.","fun_headline_variants_meta":{"raw":{"variants":["CoT tokens are variables, not just text","LLM reasoning tokens store values like code","Deleting non-value CoT tokens keeps accuracy","CoT token content, not form, drives answers","Chain-of-thought tokens act as program variables"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000173,"raw_usage":{"total_tokens":1255,"prompt_tokens":898,"completion_tokens":357,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":514,"completion_tokens_details":{"reasoning_tokens":285}},"tokens_in":514,"tokens_out":357,"duration_ms":3841,"temperature":1.0,"reasoning_tokens":285,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-15T23:17:08.832369+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"For the 5x5 dynamic-programming task with merged latent tokens, replace the linear probes with a nonlinear classifier and also measure final-answer accuracy directly; if the model's final accuracy stays high while linear-probe accuracy falls to near zero, the claimed complexity limit is a probe artifact rather than a real processing bound.","supporting_citations":[{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Documents limits of transformers on compositionality and describes shortcut behavior that explains the intervention failures observed here."}],"review_version":1}