{"id":"60ae8f8f-a950-4c60-ba7e-a28640ab82fa","arxiv_id":"2607.07144","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"unknown","formal_verification":"none","parameter_count":4,"one_line_summary":"A contractive iterated-map code losslessly serializes quantized KV-cache indices into 2D points, enabling O(1) random access, O(1) append, and direct suffix-matching retrieval without decompression.","lead":"The paper applies a classical fractal-encoding scheme (chaos game representation) to store quantized KV-cache indices for LLMs, showing it supports random access, append, and in-place suffix search. A smart generalist might read it because it reframes cache storage as a searchable index rather than an inert blob, potentially simplifying retrieval-augmented long-context inference.","discovery_kind":"unclear","skeptic_critique":{"model":"glm-5.2","headline":"Retrieval is demonstrated on natural text (small alphabet) but the KV archive stores large-alphabet codebook indices, where the contraction ratio must shrink sharply, potentially crippling the suffix-matching decay law that the retrieval claim depends on.","rationale":"The reader identified that suffix-based retrieval's utility for KV-cache management is untested, which is correct and acknowledged by the paper. However, I think the more load-bearing concern is one step deeper: the retrieval mechanism itself may not function adequately in the actual application regime. The decay law 2r^s that underpins retrieval is demonstrated on natural text with small alphabets, where r can be large (e.g., 1/2 for N≤4). The KV archive uses codebook indices with alphabet sizes of 256 or larger, where Section 2's own analysis requires r to shrink to the kissing ratio. This directly affects the retrieval property's mathematical viability, not just its practical utility. The paper is commendably honest about limitations (Section 6), but it does not flag this specific gap: the retrieval demonstration and the KV-archive application operate in different alphabet-size regimes with different contraction ratios, and the retrieval property is never tested on the actual index stream. That said, this concern does not necessarily change the verdict from CONDITIONAL. The reader already assigned CONDITIONAL with MODERATE confidence, citing untested premises. My concern reinforces this: even if one were to test retrieval utility (as the reader suggests), the more fundamental question is whether retrieval works at all in the large-alphabet regime. The verdict remains CONDITIONAL because the paper's other contributions (the codec as a storage format, the quantizer study) stand independently of the retrieval claim, and the paper is transparent about what it has and has not tested. If the concrete test above shows that r_256 still permits adequate suffix matching (say s* ≥ 8), then the retrieval claim survives and the concern dissolves; if not, the retrieval feature is the weakest link in the 'unified store + index' claim and the paper's novelty argument weakens considerably.","tokens_in":7739,"tokens_out":2419,"duration_ms":91013,"concrete_test":"Compute the kissing ratio r_N for N=256 (the per-head codebook size used in the main experiments). Then compute the maximum suffix length s* such that 2*r_N^{s*} exceeds the double-precision noise floor (~2^{-52} relative to the polygon diameter). If s* < 4, run the actual retrieval experiment from Section 4 on the KV archive index stream (not on natural text) and report recall and precision as a function of query length. If recall drops below 1.0 or precision becomes unusable for the alphabet sizes used in Table 2, the in-place retrieval claim does not hold in the application regime.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central claim is that the archive is simultaneously a store and an in-place search index (Section 4). The retrieval mechanism rests on a decay law: two positions sharing an s-symbol suffix have stored points within 2r^s of each other, so nearest-neighbor distance is a graded suffix similarity. This is demonstrated on a 100K-character corpus of natural text (Section 4, Figure 3), where the alphabet is small (ASCII/Unicode characters) and r can be relatively large. However, the actual KV archive stores codebook indices: per-head RVQ with k=256 means an alphabet of size N=256 per stage, and the combined multi-stage index stream has an even larger effective alphabet. Section 2 and Figure 1 establish that for N>4, the contraction ratio r must be tightened to the kissing ratio r_N to maintain disjoint cells (unique decodability). For N=256, r_N is much smaller than the midpoint r=1/2 used for small alphabets. This has two compounding effects on retrieval: (1) the decay 2r^s becomes much steeper, so the retrievable suffix length at a given numerical precision shrinks — fewer symbols of suffix can be matched before the signal falls below floating-point noise; (2) the per-symbol precision budget 44/log₂(1/r) decreases, shortening the span length and further constraining what can be decoded from a matched point. The paper never tests retrieval on the actual KV index stream — only on natural text. The gap between the demonstrated regime (small alphabet, large r, long matchable suffixes) and the application regime (large alphabet, small r, short matchable suffixes) is the load-bearing untested assumption. If r_256 is small enough that only 1-2 symbols of suffix are retrievable at double precision, the in-place retrieval feature is effectively vacuous for the KV-cache application it is claimed to serve.","agreement_with_reader":"partial"},"referee_report":{"model":"glm-5.2","summary":"The paper proposes using a contractive iterated-map code (chaos game representation / universal sequence map) as a serialization layer for quantized KV caches in long-context LLM inference. The code is lossless, supports O(1) random access and O(1) amortized append, and—uniquely—doubles as an in-place suffix-search index over the stored symbol stream. Around this storage layer, the authors conduct a controlled quantizer study on GPT-2 (124M) at 1024-token contexts, finding that per-head residual VQ Pareto-dominates pooled codebooks, that key quantization is ~4x more damaging than value quantization, and that a bit-asymmetric hybrid (K×4, V×2) achieves 36x compression over fp16 at +11.2% perplexity. The retrieval mechanism is demonstrated on a 100K-character natural-text corpus, showing 1.00 recall with precision governed by numerical precision.","tokens_in":8382,"tokens_out":1313,"duration_ms":216647,"significance":"The paper's central contribution is the unification of lossless storage, random-access decoding, and in-representation retrieval for KV-cache archives. The codec benchmarks (Table 1) are self-contained and reproducible, the quantizer ablations (Table 2) are carefully controlled with isolated keys-only and values-only experiments, and the code release with single-command reproduction on a laptop CPU is a genuine strength. The key/value asymmetry quantification and conversion to a bit-allocation rule is a useful, falsifiable contribution. The retrieval-as-suffix-similarity property, borrowed from the sequence-analysis literature [7,8,9], is applied here in a novel setting.","major_comments":[{"comment":"The retrieval demonstration (Section 4, Figure 3) is conducted on a 100K-character natural-text corpus, where the alphabet is small (ASCII/Unicode characters) and the contraction ratio r can be relatively large. However, the actual KV archive stores codebook indices: per-head RVQ with k=256 means an alphabet of size N=256 per stage. Section 2 and Figure 1 establish that for N>4, r must be tightened to the kissing ratio r_N to maintain disjoint cells. For N=256, r_N is much smaller than the midpoint r=1/2. This has two compounding effects on the retrieval claim: (1) the decay 2r^s becomes much steeper, so the retrievable suffix length at a given numerical precision shrinks—fewer symbols of suffix can be matched before the signal falls below floating-point noise; (2) the per-symbol precision budget 44/log₂(1/r) decreases, shortening the span length. The paper never tests retrieval on the实际","section":"Section 4 vs. Section 2/Figure 1"},{"comment":"The claim that keys and values compose 'almost independently' (1.145×1.040≈1.19 vs. the measured 1.150 for both) is used to justify the bit-asymmetric hybrid. However, the composition is tested only at a single quantization depth (k=256×2 RVQ). The hybrid allocates K×4 and V×2 stages, which is outside the regime where independence was verified. The paper notes that keys-only-×4 yields +9.4% perplexity, but does not test whether the independence assumption holds at asymmetric depths. A brief experiment testing composition at the actual hybrid allocation, or an explicit acknowledgment that the independence assumption is untested at asymmetric depths, would strengthen this load-bearing claim.","section":"Section 3, paragraph on key/value asymmetry"}],"minor_comments":[{"comment":"The statement 'Each doubling of the index budget along the RVQ axis buys back a roughly constant 8–9 perplexity points' is based on only two data points (depth 1 vs. depth 2 for per-head VQ). The claim of a 'scaling law' is overstated for two points; consider softening to 'consistent with a roughly linear trade-off' or adding a third depth.","section":"Section 3"},{"comment":"The claim that brute-force nearest-neighbor costs '≈0.9 ms/query over 100K positions' is presented without specifying the hardware beyond 'single CPU.' Since this is a 2D search, the absolute number is less important than the scaling, but the hardware specification should be stated for reproducibility.","section":"Section 4"},{"comment":"The limitation that codebooks are 'trained per corpus rather than amortized across data' is important but understated. A deployable system needs corpus-independent codebooks, and the perplexity cost of such amortization is unknown. This should be flagged more prominently, or at minimum the reader should be told that the 36x compression figure assumes per-corpus training.","section":"Section 6"},{"comment":"The 'B/token' column for 'values only' and 'keys only' rows is marked '–', but these configurations still have storage costs (the quantized component plus the exact component). Reporting the effective compression ratio for these ablation rows would improve clarity.","section":"Table 2"},{"comment":"The abstract states '36–54x' compression, but Table 2 shows 36x for the hybrid and 54x for per-head RVQ k=256×2. These are different configurations with different perplexity costs; the range conflates them. Consider stating the range with the associated perplexity costs or clarifying that the range spans different configurations.","section":"Abstract"}],"recommendation":"major_revision","confidential_remarks":"The stress-test concern about the alphabet-size gap between the retrieval demonstration (small alphabet, natural text) and the actual KV archive (N=256 codebook indices) is the most serious issue. The paper's central claim is that the archive is simultaneously a store and an in-place search index, but the search-index property is only validated in a regime that does not match the deployed setting. If the authors can show that retrieval remains practical at N=256 (even with reduced matchable suffix length), the paper's contribution is substantially strengthened. If they cannot, the retrieval claim should be re-scoped. The concurrent work FibQuant [5] and RetroInfer [6] are cited as related work; the authors are transparent about the overlap and do not claim priority, which is appropriate."},"author_rebuttal":null,"desk_editor":{"model":"glm-5.2","letter":"The paper's real contribution is the observation that a classical contractive iterated-map code (chaos game representation) can serve as a KV-cache archive that is simultaneously a lossless store, a random-access decoder, and an in-place suffix-search index. The code itself is not new, and the paper is honest about that. What is new is the specific application and the unification of storage and retrieval in one representation. Code is released with a single-command reproducibility claim on a laptop CPU, which I take as real evidence that the numbers are checkable. The storage and quantizer parts hold up. Table 1 is a clean self-contained benchmark: lossless round-trips, linear encoding, sub-millisecond random access, fast append. Table 2 is a well-controlled study: per-head codebooks Pareto-dominate pooled ones at equal bit budget, the 4x key/value asymmetry is measured cleanly with proper ablations (keys-only vs values-only), and the bit-asymmetric hybrid is a sensible default. The mechanism for the asymmetry (values enter attention through a weighted average, keys through routing) is sound. The soft spot is the retrieval claim, and it is the paper's most novel one. Section 4 demonstrates suffix retrieval on a 100K-character natural-text corpus, where the alphabet is small and the contraction ratio r can stay near 1/2. But the actual KV archive stores codebook indices: per-head RVQ with k=256 means an alphabet of N=256 per stage, and the paper itself establishes (Section 2, Figure 1) that for N>4, r must shrink to the kissing ratio to maintain unique decodability. For N=256, r is much smaller, which has two compounding effects: the decay 2r^s steepens sharply (shorter matchable suffixes), and the per-symbol precision budget 44/log2(1/r) drops (shorter decodable spans). The paper never tests retrieval on the actual KV index stream. The gap between the demonstrated regime and the application regime is the load-bearing untested assumption. If r for N=256 is small enough that only 1-2 symbols of suffix are retrievable at double precision, the in-place retrieval feature is effectively vacuous for the use case it is claimed to serve. I agree with the stress-test on this point. The scale limitations (GPT-2 124M, 1024 tokens, perplexity only) are real but honestly acknowledged in Section 6. The compression ratio comes from the quantizer, not the codec, which the paper admits. These are minor relative to the retrieval gap. This paper is for researchers working on KV-cache compression who care about storage representation as a design choice. The quantizer study and codec benchmark have standalone value. The retrieval claim needs validation in the large-alphabet regime before it carries practical weight. I would give this a serious referee: the storage and quantizer work is solid, and the retrieval idea is worth checking even if the current demonstration does not reach the application regime.","headline":"Storage and quantizer contributions are solid; the retrieval claim is demonstrated in the wrong regime","tokens_in":8585,"tokens_out":4599,"would_cite":false,"duration_ms":204613,"reading_group":"no","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"glm-5.2","headline":"Fractal storage turns KV-cache into its own search index","keywords":["KV-cache compression","iterated function systems","chaos game representation","vector quantization","suffix retrieval","lossless storage","contractive maps"],"falsifier":"Show that suffix-matching retrieval on the archive does not correlate with positions an LLM actually attends to during inference, or that the 2D nearest-neighbor search produces unmanageable false-positive rates at context lengths beyond 1024 tokens, or that the codec's O(1) access degrades as floating-point error accumulates across very long sequences.","tokens_in":7721,"feed_emoji":"🗂️","tokens_out":2516,"duration_ms":187934,"temperature":0.7,"pith_summary":"The paper takes a classical contractive iterated-map code — known in bioinformatics as chaos game representation — and applies it as the serialization layer for a quantized LLM key-value cache. The code reads a stream of codebook indices (symbols) and maps each one to a contraction toward a vertex of a regular polygon, producing a trajectory of points in the plane. Because each contraction step makes the running point forget older symbols at a geometric rate, two cache positions that share a recent token suffix end up with nearby stored points. This geometric decay means the archive is not merely a compressed blob: nearest-neighbor distance in the 2D point space is a graded suffix-similarity measure, so approximate substring queries execute directly on the stored vectors at full recall, and matched context decodes backward from the matched point through stored anchors without ever touching the surrounding text. The paper verifies the codec is lossless, linear-time, and supports O(1) random access and O(1) amortized append — the exact operations a growing cache needs. Around this storage layer, the paper runs a controlled quantizer study on GPT-2 at 1024-token contexts, keeping a small exact window (4 attention sinks + 32 recent tokens) and archiving the rest. Per-head residual vector quantization Pareto-dominates pooled codebooks at equal bit budget. The paper quantifies a roughly 4× asymmetry: quantizing keys is far more damaging than quantizing values, because key error corrupts attention routing (which memories get read) while value error is attenuated by the weighted average. A bit-asymmetric hybrid — four RVQ stages for keys, two for values — achieves 36× compression versus an fp16 cache at +11.2% perplexity, the best operating point in the sweep. The paper is explicit that the compression ratio comes from the vector quantizer, not from the fractal codec; the codec's contribution is that the resulting archive is simultaneously a store, a random-access decoder, and an in-place search index — a unification not previously applied to the KV-cache setting.","feed_headline":"Fractal storage turns KV-cache into its own search index","feed_subtitle":"A classical iterated-map code unifies lossless storage, random access, and in-place retrieval for compressed LLM memory — the archive is its","key_machinery":"Contractive iterated-map code (chaos game representation): each symbol maps a running point by p_k = V(c_k) + r(p_{k-1} - V(c_k)), where V(c_k) is the polygon vertex for symbol c_k and r is a contraction ratio bounded by a packing constant so that symbol cells remain disjoint and the code is uniquely decodable. Decoding inverts the map by identifying which cell contains the point. Because each step contracts by r, a stored point is dominated by recent symbols; two positions sharing an s-symbol suffix have points within 2r^s of each other, making nearest-neighbor distance a graded suffix similarity.","core_discovery":"The central object is the contractive iterated-map code applied to quantized KV-cache index streams. Each symbol contracts a running point toward a polygon vertex, and because the contraction makes older symbols decay geometrically, two positions sharing a recent suffix have nearby stored points. This makes the archive searchable without decompression: nearest-neighbor distance in 2D is a graded suffix-similarity, so the storage representation doubles as a retrieval index. The paper shows this works at full recall across query lengths, with precision governed by floating-point precision relative to the contraction ratio, and that matched context decodes backward from the matched point alone.","pith_inferences":["Suffix matching would be most useful for repeated patterns (boilerplate, code blocks, citations) where exact token suffixes recur; its value for novel prose or paraphrased context is less clear and untested","Combining this storage format with a stronger quantizer than plain k-means could improve the rate-distortion frontier without changing the retrieval properties of the archive","The 2D representation's information capacity is bounded by floating-point precision, which may limit scalability to very long contexts where suffix collisions accumulate and false-positive rates rise","If the code's decay weighting could be generalized beyond pure recency — for instance, to weight by attention scores — the retrieval might approximate attention-relevant locality rather than pure sequence locality"],"forward_implications":["If suffix-based retrieval on the archive correlates with attention-relevant context, inference engines could selectively rehydrate only matching cache positions rather than scanning or decompressing the full cache","The 2D search space (rather than high-dimensional embedding space) means standard spatial indexing structures can accelerate lookups cheaply, with brute-force nearest-neighbor costing under 1 ms per query over 100K positions","The key/value asymmetry quantified as a perplexity budget gives a principled bit-allocation rule: spend roughly four times as many quantization stages on keys as on values","The unification of storage and retrieval in one representation suggests cache management could skip the decompress-then-search pipeline entirely, operating directly on the compressed archive"],"fun_headline_variants":["KV-cache archive doubles as search index without decompression","Fractal code stores compressed KV-cache and retrieves in place","Quantized KV-cache becomes searchable via iterated-map encoding","Contractive codes turn KV-cache storage into retrieval index","Lossless KV-cache archive supports O(1) access and direct search"],"cache_read_input_tokens":0,"weakest_assumption_plain":"The retrieval mechanism matches exact token suffixes, not semantic content. Whether matching exact token suffixes is a useful operation for managing an LLM's attention during real inference is untested — if attention patterns do not correlate with suffix overlap, the in-place retrieval feature adds complexity without practical benefit.","fun_headline_variants_meta":{"raw":{"variants":["KV-cache archive doubles as search index without decompression","Fractal code stores compressed KV-cache and retrieves in place","Quantized KV-cache becomes searchable via iterated-map encoding","Contractive codes turn KV-cache storage into retrieval index","Lossless KV-cache archive supports O(1) access and direct search"]},"model":"glm-5.2","effort":"low","cost_usd":0.0,"raw_usage":{"total_tokens":764,"prompt_tokens":683,"completion_tokens":81,"prompt_tokens_details":null},"tokens_in":683,"tokens_out":81,"duration_ms":79397,"temperature":1.0,"reasoning_tokens":null,"cache_read_input_tokens":0,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-07-09T18:58:50.175463+00:00","model_set":{"reader":"glm-5.2"},"falsifier":"Show that suffix-matching retrieval on the archive does not correlate with positions an LLM actually attends to during inference, or that the 2D nearest-neighbor search produces unmanageable false-positive rates at context lengths beyond 1024 tokens, or that the codec's O(1) access degrades as floating-point error accumulates across very long sequences.","supporting_citations":[],"review_version":1}