Pith. sign in

REVIEW 2 major objections 5 minor 39 references

Lossless Token Sequence Compression via Meta-Tokens

T0 review · 2 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read A lossless dictionary transform shrinks LLM prompts by replacing repeated token subsequences with single meta-tokens, preserving all information while nearly matching uncompressed accuracy.

desk verdict Clever LZ77-style prompt compression, but the lossless claim hinges on a pseudocode ambiguity in Algorithm 2; deserves review after fixes and code release. read the letter →

arxiv 2506.00307 v2 pith:JHQFYSHR submitted 2025-05-30 cs.CL cs.AIcs.LG

John Harvill , Ziwei Fan , Hao Wang , Luke Huan , Anoop Deoras , Yizhou Sun , Hao Ding This is my paper
classification cs.CLcs.AIcs.LG
keywords losslesspromptcompressionmeta-tokenstokensequenceLZ77transformerattentioncostrepository-levelcodecompletiontreestructureunderstanding
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Lossless Token Sequence Compression (LTSC) is a way to shrink the token sequence fed to a transformer LLM before inference. It finds multi-token subsequences that repeat inside a prompt, replaces each occurrence with a single meta-token, and prepends a dictionary that maps every meta-token back to the token subsequence it stands for. Because every original token appears exactly once in the dictionary or the compressed stream, the transform is reversible and no information is lost. On two tasks where all input is load-bearing, tree structure understanding and repository-level code completion, LTSC reduces average sequence length by 27% and 18%; the authors estimate this cuts attention computation by 47% and 33% because attention cost scales quadratically with length. Fine-tuned LLMs using the compressed format nearly match their uncompressed baselines, while a leading lossy compressor fails on both tasks, and the paper presents LTSC as the first lossless prompt compression method.

What carries the argument

The load-bearing object is the meta-token dictionary: a set of pairs mapping newly added vocabulary tokens to exact multi-token subsequences, prepended to the compressed prompt inside <Dict> tags. The compression condition is the inequality $N \cdot K > 1 + N + K$, where $N$ is subsequence length and $K$ is its non-overlapping occurrence count; solving it gives three profitable regimes: $N \geq 4$ with $K \geq 2$, $N = 3$ with $K \geq 3$, and $N = 2$ with $K \geq 4$. The algorithm discovers candidate subsequences up to a maximum length $L_{\max}$, greedily swaps non-overlapping occurrences for meta-tokens while checking that the inequality still holds, and builds the dictionary. The dictionary is what makes the transform reversible, and including its length in the compression ratio keeps the reported savings honest.

What would settle it

Compress a collection of long token sequences with Algorithms 1-3, expand every meta-token using its dictionary entry, delete the <Dict> block, and compare the result to the original stream token-by-token; any mismatched sequence would disprove the lossless claim.

Watch

Extended reading notes

Core claim

The central claim is that token sequences are redundant enough that a lossless, dictionary-based transform yields real compression on practical prompts, and that transformer LLMs can learn to work with the transformed format after light fine-tuning. The mechanism is the meta-token substitution rule: a repeated subsequence of length $N$ occurring $K$ non-overlapping times costs $N \cdot K$ tokens originally, versus $1 + N + K$ tokens when represented by a dictionary entry plus $K$ meta-tokens, so compression pays off exactly when $N \cdot K > 1 + N + K$. On information-dense tasks, this preserves all semantics, avoids the collapse seen with lossy compression, and leaves only a small accuracy gap to the uncompressed model that shrinks with model scale. The paper attributes the feasibility of the transform to the fact that transformers attend over sets rather than reading strictly left to right, so an input can be rearranged into a denser representation without breaking the model.

Load-bearing premise

The method assumes the compression transform is exactly reversible for every token sequence, with no edge cases from overlapping subsequences or token-boundary interactions when meta-tokens are expanded back into dictionary entries.

Editorial extensions

If this is right

  • Lossy prompt compression is the wrong tool for inputs where every token carries structure: the lossy baseline falls below 1% Exact Match on code completion even at modest compression, while LTSC stays close to the uncompressed baseline.
  • Because transformer attention scales quadratically, the measured 27% and 18% length reductions translate to roughly 47% and 33% less encoder computation on the two evaluated tasks.
  • A single model fine-tuned on a mix of compressed and uncompressed prompts can accept either format at inference time, so compression can be toggled per request without retraining.
  • The gap between LTSC and no compression shrinks as model scale grows, and the paper conjectures that larger models with longer fine-tuning would close it entirely.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Beyond the paper: applying the same dictionary mechanism to model output could cut generation cost, but the paper reports that initial attempts produced poor results; making output-side meta-tokens work is an open problem.
  • Beyond the paper: compressibility depends on tokenizer vocabulary size, so choosing or training a tokenizer with LTSC in mind could push compression beyond the 18-27% range reported here.
  • Beyond the paper: a natural stress test is long-context retrieval or question answering, where the fixed dictionary overhead is amortized over very long inputs and exact token recovery matters.
  • Beyond the paper: the compression amount itself could serve as a cheap redundancy diagnostic, identifying which prompts would benefit most before any model call is made.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

2 major / 5 minor

Summary. The paper introduces Lossless Token Sequence Compression (LTSC), a method that identifies repeated multi-token subsequences and replaces them with newly added vocabulary tokens (meta-tokens), prepending a dictionary of (meta-token, subsequence) pairs to the input. The authors derive a per-subsequence compressibility inequality (Eq. 1), present Algorithms 1-3 for discovery, swapping, and dictionary construction, and evaluate on tree-structure understanding and RepoBench code completion with several model sizes. They report average input length reductions of 27.1% and 17.9% on the two tasks and find that limited fine-tuning lets models perform close to the uncompressed baseline, whereas LLMLingua2 collapses on these information-dense tasks. They claim to be the first to propose lossless prompt compression.

Significance. The core observation that repeated token n-grams can be replaced by dictionary tokens with a reversible transformation is simple and useful, and the experimental demonstration that LLMs can adapt to this format with modest fine-tuning is an interesting positive result. If the losslessness guarantee is made rigorous, the method would be a practical, task-agnostic way to reduce attention cost without information loss. The paper's strengths include a constructive algorithm, clear presentation of Eq. (1), a large-scale evaluation across six model sizes, and a demonstration that a strong lossy baseline fails on tasks requiring exact syntax. The main weaknesses are that the central 'lossless' claim rests on an informal argument and on pseudocode with a load-bearing ambiguity, and no code or data are provided to verify the edge cases.

major comments (2)
  1. [Section 4, Algorithm 2] The overlap-removal step is specified inconsistently. The pseudocode line 'I ← I \ Iswap' performs a set difference on start indices only, while the adjacent comment and the prose state that the intended check is that no index within the span [i, i + |Tsub| − 1] belongs to Iswap. Under the literal set-difference reading, after a swap has occupied positions 3–4, a later candidate of length 3 starting at position 2 is not rejected, since 2 is not in Iswap; the two swaps overlap and the transformation is no longer invertible. Because losslessness is the central claim, this must be fixed: either correct the pseudocode to remove any start index whose span intersects Iswap, or provide a formal invariant that guarantees all chosen swaps are pairwise non-overlapping.
  2. [Section 4, Figure 3 caption] The 'lossless' property is asserted rather than proven. Equation (1) is a per-subsequence length comparison and does not by itself establish that executing Algorithm 2 on all candidate subsequences (with the dictionary prefix, tag tokens, and position shifts) always yields a sequence from which the original T can be exactly reconstructed. I request a short induction on the sorted swap list, or an explicit specification of the allowed input class, together with a direct round-trip reconstruction test on the evaluation data. The reported task accuracies would not detect the rare overlapping-swap failures described in the previous comment.
minor comments (5)
  1. [Section 6.1] The phrase 'LLMLingua2 achives' should be 'achieves'.
  2. [Figure 5 and Table 1] The y-axis label 'Performance Ga' in Figure 5 should be 'Gap', and the header 'Agv. Len.' in Table 1 should be 'Avg. Len.'.
  3. [Algorithm 2] The comment on the line 'I ← I \ Iswap' should be rewritten so that it matches the intended span-based overlap check; the current comment does not correspond to the operation shown.
  4. [General] The paper does not include a code or data release; providing an anonymized link to the implementation would allow the edge cases of the algorithm to be checked independently.
  5. [Section 2] The novelty claim 'we are the first to propose lossless compression for prompting' could be softened or accompanied by a more explicit comparison with LZ77 and other dictionary-based methods, beyond a brief analogy.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity found: the central compression claim is a constructive algorithm with an explicit counting inequality, and the empirical claims are evaluated on held-out data.

full rationale

The paper's derivation chain is self-contained and does not reduce to its inputs. Equation (1) is a simple counting inequality, N*K > 1+N+K, comparing the tokens used by repeated subsequences against the cost of a dictionary plus meta-token replacements; it is not fitted to the downstream results, and the compression amounts reported in Figure 2 and Tables 1-2 include the dictionary length as stated in Section 2. The losslessness claim rests on a constructive transformation (Algorithms 1-3) that is claimed to be reversible by replacing each meta-token with its dictionary subsequence and removing the dictionary. This is a design property of the algorithm, not a conclusion defined into existence by the evaluation. The experimental claims are not circular: models are fine-tuned on training splits and evaluated on held-out test data, so the observation that fine-tuned LLMs handle meta-tokens is an empirical result rather than a fitted prediction. There are no load-bearing self-citations: the references to Ziv-Lempel, RepoBench, CommitPack, and LLMLingua2 are external prior work, and no uniqueness theorem or author-specific prior result is invoked to force the choice of method. The only notable weakness is that Algorithm 2's overlap-removal step (`I <- I \ Iswap`) is specified ambiguously and the losslessness claim is asserted rather than formally proven; however, this is a correctness and completeness risk, not a circularity, because it does not define the outcome in terms of itself or rename a fitted input as a prediction.

Assumptions & free parameters 3 free parameters · 3 assumptions · 1 invented entities

The method relies on a few hand-picked hyperparameters (Lmax, number of meta-tokens, training steps) and on the empirical assumption that LLMs can learn to use the compressed format. The meta-token mechanism is a design artifact of the paper. No new physical or mathematical entities are postulated.

free parameters (3)
  • Lmax (maximum subsequence length) = 6
    Chosen by hand to bound the search; affects compression amount.
  • Number of meta-tokens |M| = 500
    Chosen based on observed usage (200-300 for 10k-length sequences); must be large enough to cover dictionary entries.
  • Training steps (CommitPack + RepoBench) = 630 + 80
    Selected by validation loss; not justified as optimal.
assumptions (3)
  • domain assumption Transformer-based LLMs can learn to understand meta-token substitutions with fine-tuning, and their performance on compressed inputs approximates uncompressed inputs.
    This is the core empirical premise; the paper tests it on two tasks, but it is not guaranteed for all tasks or larger scales.
  • domain assumption The tokenizer's vocabulary can be extended with new tokens without breaking the model's other capabilities.
    Standard assumption when adding tokens; the paper validates it via fine-tuning experiments.
  • ad hoc to paper The dictionary format using <Dict> and </Dict> tags is a valid and understandable input for the fine-tuned LLM.
    This is a design choice of the proposed method, not an independent fact.
invented entities (1)
  • Meta-tokens
    purpose: Placeholder tokens that replace repeated subsequences in the input sequence
    Introduced solely for this method; their utility is demonstrated only within the paper's fine-tuned models, with no external validation beyond these experiments.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Lossless Token Sequence Compression via Meta-Tokens." pith.science (2026). https://pith.science/paper/JHQFYSHR

@misc{pith2026250600307,
  author       = {Pith},
  title        = {Pith review of: Lossless Token Sequence Compression via Meta-Tokens},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/JHQFYSHR}},
  note         = {Machine review of arXiv:2506.00307}
}
read the original abstract

Existing work on prompt compression for Large Language Models (LLM) focuses on lossy methods that try to maximize the retention of semantic information that is relevant to downstream tasks while significantly reducing the sequence length. In this paper, we introduce a task-agnostic lossless compression technique similar to LZ77 that makes it possible to reduce the input token sequence length on average by 27\% and 18\% for the two evaluation tasks explored here. Given that we use transformer-based LLMs, this equates to 47\% and 33\% less encoding computation, respectively, due to the quadratic nature of attention. The token sequence transformation is trivial to reverse and highlights that no semantic information is lost in the process. We evaluate our proposed approach on two tasks that require strict preservation of semantics/syntax and demonstrate that existing lossy compression methods perform poorly in this setting. We find that our lossless compression technique produces only a small gap in performance compared to using the uncompressed input and posit that larger models and an expanded computing budget would likely erase the gap entirely.

Figures

Figures reproduced from arXiv: 2506.00307 by the authors.

Figure 1
Figure 1. Example of swapping repeated subse [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Compression amounts by sequence length for Natural Language (NL) and code domains with two tokenizers (Qwen: Qwen2.5-Coder, SC: Star￾Coder2). token usage, improve generation latency, or make information denser under a fixed context length budget. Some existing work allows con￾trol over how much the prompt is compressed Jiang et al. [2023a], Pan et al. [2024b], but for our proposed approach, the maximum amount of com… view at source ↗
Figure 3
Figure 3. Visualization of the compression process. We exclude the XML tags <Dict> and [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (4 more)
Figure 5
Figure 5. Figure 5: Relative performance gap between LTSC and vanilla model (no compression) on repository￾level code completion for a variety of model sizes. to vanilla models not using compression. We find the relative performance gap between LTSC and vanilla models becomes signifi￾cant…
Figure 6
Figure 6. Figure 6: Runtime of compression process for Wikipedia data tokenized by [PITH_FULL_IMAGE:figures/full_fig_p014_6.png]
Figure 7
Figure 7. Figure 7: t-SNE plot of meta-tokens and original vocabulary tokens for the StarCoder2-7B model [PITH_FULL_IMAGE:figures/full_fig_p015_7.png]
Figure 8
Figure 8. Figure 8: Number of dictionary tokens used by LTSC for natural language token sequences of varying lengths. F Dataset License Repobench Liu et al. [2024] maintains a Creative Commons license. CommitPack Muennighoff et al. [2024] maintains an MIT license. 16 [PITH_FULL_IMAGE:fig…

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

39 extracted references · 5 canonical work pages

  1. [1]

    Adapting language models to compress contexts

    Alexis Chevalier, Alexander Wettig, Anirudh Ajith, and Danqi Chen. Adapting language models to compress contexts. In Houda Bouamor, Juan Pino, and Kalika Bali, editors, Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, pages 3829--3846, Singapore, December 2023. Association for Computational Linguistics. doi:10.18653/...

    doi:10.18653/v1/2023.emnlp-main.232 2023

  2. [2]

    Learning to compress prompt in natural language formats

    Yu-Neng Chuang, Tianwei Xing, Chia-Yuan Chang, Zirui Liu, Xun Chen, and Xia Hu. Learning to compress prompt in natural language formats. In Kevin Duh, Helena Gomez, and Steven Bethard, editors, Proceedings of the 2024 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies (Volume 1: Long Pape...

    doi:10.18653/v1/2024.naacl-long.429 2024

  3. [3]

    UniICL: An Efficient Unified Framework Unifying Compression, Selection, and Generation

    Jun Gao, Ziqiang Cao, and Wenjie Li. Unifying demonstration selection and compression for in-context learning, 2024. URL https://arxiv.org/abs/2405.17062

    work page Pith review arXiv 2024

  4. [4]

    In-context autoencoder for context compression in a large language model

    Tao Ge, Jing Hu, Lei Wang, Xun Wang, Si-Qing Chen, and Furu Wei. In-context autoencoder for context compression in a large language model. arXiv preprint arXiv:2307.06945, 2023

    arXiv 2023

  5. [5]

    Alex Gu, Baptiste Rozière, Hugh Leather, Armando Solar-Lezama, Gabriel Synnaeve, and Sida I. Wang. Cruxeval: A benchmark for code reasoning, understanding and execution, 2024. URL https://arxiv.org/abs/2401.03065

    arXiv 2024

  6. [6]

    Melody Y. Guan, Manas Joglekar, Eric Wallace, Saachi Jain, Boaz Barak, Alec Helyar, Rachel Dias, Andrea Vallone, Hongyu Ren, Jason Wei, Hyung Won Chung, Sam Toyer, Johannes Heidecke, Alex Beutel, and Amelia Glaese. Deliberative alignment: Reasoning enables safer language models, 2025. URL https://arxiv.org/abs/2412.16339

    arXiv 2025

  7. [7]

    Long short-term memory

    S Hochreiter and J Schmidhuber. Long short-term memory. Neural computation, 9 0 (8): 0 1735--1780, 1997

    work page 1997

  8. [8]

    Lora: Low-rank adaptation of large language models

    Edward J Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. Lora: Low-rank adaptation of large language models. arXiv preprint arXiv:2106.09685, 2021

    arXiv 2021

Show all 39 references
  1. [9]

    Llmlingua: Compressing prompts for accelerated inference of large language models

    Huiqiang Jiang, Qianhui Wu, Chin-Yew Lin, Yuqing Yang, and Lili Qiu. Llmlingua: Compressing prompts for accelerated inference of large language models. arXiv preprint arXiv:2310.05736, 2023 a

    2023 arXiv

  2. [10]

    Longllmlingua: Accelerating and enhancing llms in long context scenarios via prompt compression

    Huiqiang Jiang, Qianhui Wu, Xufang Luo, Dongsheng Li, Chin-Yew Lin, Yuqing Yang, and Lili Qiu. Longllmlingua: Accelerating and enhancing llms in long context scenarios via prompt compression. arXiv preprint arXiv:2310.06839, 2023 b

    arXiv

  3. [11]

    Discrete prompt compression with reinforcement learning

    Hoyoun Jung and Kyung-Joong Kim. Discrete prompt compression with reinforcement learning. IEEE Access, 12: 0 72578--72587, 2024. doi:10.1109/ACCESS.2024.3403426

    2024

  4. [12]

    Scaling laws for neural language models

    Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. Scaling laws for neural language models. arXiv preprint arXiv:2001.08361, 2020

    2001 arXiv

  5. [13]

    The power of scale for parameter-efficient prompt tuning

    Brian Lester, Rami Al-Rfou, and Noah Constant. The power of scale for parameter-efficient prompt tuning. In Marie-Francine Moens, Xuanjing Huang, Lucia Specia, and Scott Wen-tau Yih, editors, Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processin...

    2021 doi

  6. [14]

    How do students use chatgpt as a writing support? Journal of Adolescent & Adult Literacy, 2024

    Sarah Levine, Sarah W Beck, Chris Mah, Lena Phalen, and Jaylen PIttman. How do students use chatgpt as a writing support? Journal of Adolescent & Adult Literacy, 2024

    2024

  7. [15]

    Prefix-tuning: Optimizing continuous prompts for generation

    Xiang Lisa Li and Percy Liang. Prefix-tuning: Optimizing continuous prompts for generation. In Chengqing Zong, Fei Xia, Wenjie Li, and Roberto Navigli, editors, Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International J...

    2021 doi

  8. [16]

    Compressing context to enhance inference efficiency of large language models

    Yucheng Li, Bo Dong, Frank Guerin, and Chenghua Lin. Compressing context to enhance inference efficiency of large language models. In Houda Bouamor, Juan Pino, and Kalika Bali, editors, Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, pag...

    2023 doi

  9. [17]

    Prompt compression for large language models: A survey, 2024 a

    Zongqian Li, Yinhong Liu, Yixuan Su, and Nigel Collier. Prompt compression for large language models: A survey, 2024 a . URL https://arxiv.org/abs/2410.12388

    2024 arXiv

  10. [18]

    500xcompressor: Generalized prompt compression for large language models, 2024 b

    Zongqian Li, Yixuan Su, and Nigel Collier. 500xcompressor: Generalized prompt compression for large language models, 2024 b . URL https://arxiv.org/abs/2408.03094

    2024 arXiv

  11. [19]

    Prompt compression with context-aware sentence encoding for fast and improved llm inference, 2024

    Barys Liskavets, Maxim Ushakov, Shuvendu Roy, Mark Klibanov, Ali Etemad, and Shane Luke. Prompt compression with context-aware sentence encoding for fast and improved llm inference, 2024. URL https://arxiv.org/abs/2409.01227

    2024 arXiv

  12. [20]

    TCRA - LLM : Token compression retrieval augmented large language model for inference cost reduction

    Junyi Liu, Liangzhi Li, Tong Xiang, Bowen Wang, and Yiming Qian. TCRA - LLM : Token compression retrieval augmented large language model for inference cost reduction. In Houda Bouamor, Juan Pino, and Kalika Bali, editors, Findings of the Association for Computational Linguisti...

    2023 doi

  13. [21]

    Repobench: Benchmarking repository-level code auto-completion systems, 2024

    Tianyang Liu, Canwen Xu, and Julian McAuley. Repobench: Benchmarking repository-level code auto-completion systems, 2024. URL https://arxiv.org/abs/2306.03091

    2024 arXiv

  14. [22]

    Learning to compress prompts with gist tokens

    Jesse Mu, Xiang Li, and Noah Goodman. Learning to compress prompts with gist tokens. Advances in Neural Information Processing Systems, 36, 2024

    2024

  15. [23]

    Octopack: Instruction tuning code large language models, 2024

    Niklas Muennighoff, Qian Liu, Armel Zebaze, Qinkai Zheng, Binyuan Hui, Terry Yue Zhuo, Swayam Singh, Xiangru Tang, Leandro von Werra, and Shayne Longpre. Octopack: Instruction tuning code large language models, 2024. URL https://arxiv.org/abs/2308.07124

    2024 arXiv

  16. [24]

    Training software engineering agents and verifiers with swe-gym

    Jiayi Pan, Xingyao Wang, Graham Neubig, Navdeep Jaitly, Heng Ji, Alane Suhr, and Yizhe Zhang. Training software engineering agents and verifiers with swe-gym. arXiv preprint arXiv:2412.21139, 2024 a

    2024 arXiv

  17. [25]

    Llmlingua-2: Data distillation for efficient and faithful task-agnostic prompt compression

    Zhuoshi Pan, Qianhui Wu, Huiqiang Jiang, Menglin Xia, Xufang Luo, Jue Zhang, Qingwei Lin, Victor R \"u hle, Yuqing Yang, Chin-Yew Lin, et al. Llmlingua-2: Data distillation for efficient and faithful task-agnostic prompt compression. arXiv preprint arXiv:2403.12968, 2024 b

    2024 arXiv

  18. [26]

    Using the output embedding to improve language models

    Ofir Press and Lior Wolf. Using the output embedding to improve language models. In Mirella Lapata, Phil Blunsom, and Alexander Koller, editors, Proceedings of the 15th Conference of the E uropean Chapter of the Association for Computational Linguistics: Volume 2, Short Papers...

    2017

  19. [27]

    Bidirectional recurrent neural networks

    Mike Schuster and Kuldip K Paliwal. Bidirectional recurrent neural networks. IEEE transactions on Signal Processing, 45 0 (11): 0 2673--2681, 1997

    1997

  20. [28]

    Taco-rl: Task aware prompt compression optimization with reinforcement learning, 2024

    Shivam Shandilya, Menglin Xia, Supriyo Ghosh, Huiqiang Jiang, Jue Zhang, Qianhui Wu, and Victor Rühle. Taco-rl: Task aware prompt compression optimization with reinforcement learning, 2024. URL https://arxiv.org/abs/2409.13035

    2024 arXiv

  21. [29]

    Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, Y. K. Li, Y. Wu, and Daya Guo. Deepseekmath: Pushing the limits of mathematical reasoning in open language models, 2024. URL https://arxiv.org/abs/2402.03300

    2024 arXiv

  22. [30]

    Scaling llm test-time compute optimally can be more effective than scaling model parameters

    Charlie Snell, Jaehoon Lee, Kelvin Xu, and Aviral Kumar. Scaling llm test-time compute optimally can be more effective than scaling model parameters. arXiv preprint arXiv:2408.03314, 2024

    2024 arXiv

  23. [31]

    Comparing traditional and llm-based search for consumer choice: A randomized experiment

    Sofia Eleni Spatharioti, David M Rothschild, Daniel G Goldstein, and Jake M Hofman. Comparing traditional and llm-based search for consumer choice: A randomized experiment. arXiv preprint arXiv:2307.03744, 2023

    2023 arXiv

  24. [32]

    Is chatgpt the ultimate programming assistant--how far is it? arXiv preprint arXiv:2304.11938, 2023

    Haoye Tian, Weiqi Lu, Tsz On Li, Xunzhu Tang, Shing-Chi Cheung, Jacques Klein, and Tegawend \'e F Bissyand \'e . Is chatgpt the ultimate programming assistant--how far is it? arXiv preprint arXiv:2304.11938, 2023

    2023 arXiv

  25. [33]

    Visualizing data using t-sne

    Laurens Van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of machine learning research, 9 0 (11), 2008

    2008

  26. [34]

    Attention is all you need

    A Vaswani. Attention is all you need. Advances in Neural Information Processing Systems, 2017

    2017

  27. [35]

    Chain-of-thought prompting elicits reasoning in large language models

    Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V Le, Denny Zhou, et al. Chain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems, 35: 0 24824--24837, 2022

    2022

  28. [36]

    Scaling embedding layers in language models

    Da Yu, Edith Cohen, Badih Ghazi, Yangsibo Huang, Pritish Kamath, Ravi Kumar, Daogao Liu, and Chiyuan Zhang. Scaling embedding layers in language models. arXiv preprint arXiv:2502.01637, 2025

    2025

  29. [37]

    Adacomp: Extractive context compression with adaptive predictor for retrieval-augmented large language models, 2024 a

    Qianchi Zhang, Hainan Zhang, Liang Pang, Hongwei Zheng, and Zhiming Zheng. Adacomp: Extractive context compression with adaptive predictor for retrieval-augmented large language models, 2024 a . URL https://arxiv.org/abs/2409.01579

    2024 arXiv

  30. [38]

    Llm as a mastermind: A survey of strategic reasoning with large language models

    Yadong Zhang, Shaoguang Mao, Tao Ge, Xun Wang, Adrian de Wynter, Yan Xia, Wenshan Wu, Ting Song, Man Lan, and Furu Wei. Llm as a mastermind: A survey of strategic reasoning with large language models. arXiv preprint arXiv:2404.01230, 2024 b

    2024 arXiv

  31. [39]

    Ziv and A

    J. Ziv and A. Lempel. A universal algorithm for sequential data compression. IEEE Transactions on Information Theory, 23 0 (3): 0 337--343, 1977. doi:10.1109/TIT.1977.1055714

    1977

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.