{"id":"fd03e2df-d4f3-4b7f-8554-f605cceed1ec","arxiv_id":"2505.19561","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"high","formal_verification":"none","parameter_count":3,"one_line_summary":"The Lego sketch is a scalable neural sketch that partitions a data stream into multiple memory bricks via hashing, with a Deep Sets-based scanning module and self-guided loss to improve frequency estimation.","lead":"This paper proposes the Lego sketch, a memory-augmented neural network that estimates item frequencies in data streams by combining hash embeddings with a modular set of memory bricks that grows with the space budget. It claims better accuracy than prior handcrafted and neural sketches across domains and budgets, plus the first error bound for a neural sketch.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Theorem 4.3's error bound assumes E[v_j^k/v_i^k] ≤ 1, which fails for i.i.d. positive embeddings: Jensen gives ≥ 1 with strict inequality unless v is constant, so the claimed (ε d2)^{-1} bound is unproven.","rationale":"The reader's weakest_assumption focused on Theorem 4.2 and the memory-scalability transfer of the scanning module, flagging the heuristic distributional assumptions in Appendix F. The rationale also noted that 'Theorem 4.3 rests on an unproven expectation,' which is the concern I develop here. I chose Theorem 4.3 as the single most load-bearing concern because it is a sharper, more decisive issue: the proof contains an inequality that is generally false for i.i.d. positive random variables, not merely a heuristic approximation. The claimed 'first error bound for neural sketch' is a headline contribution in the abstract and contributions list; if the bound is unsupported, the theoretical novelty is materially weakened. Theorem 4.2 is concerning but its conclusion (sub-stream skewness approximates global skewness after excluding top items) is plausible and empirically supported by the multi-brick scaling experiments; it affects the strength of the scalability guarantee but does not invalidate the architecture. The error-bound flaw is independent of experiments and directly contradicts a stated contribution. The reader's conditional verdict remains appropriate: the empirical architecture may still be sound, but the theory needs correction or restatement. I therefore recommend no change to the reader's CONDITIONAL verdict, with the concrete test above serving to either confirm the flaw or reveal that the bound holds by a different argument.","tokens_in":17161,"tokens_out":11665,"duration_ms":121023,"concrete_test":"Load the released code and trained checkpoint; extract the learned embedding vector V. Draw 10^6 independent pairs of items and compute, for a fixed embedding hash k, the ratio r = (V_{H_k(j)} / Σ_l V_{H_l(j)}) / (V_{H_k(i)} / Σ_l V_{H_l(i)}). Estimate E[r]. If the estimate exceeds 1 (as Jensen predicts for non-constant V), the equality in Appendix G is false. Then simulate a synthetic Zipf stream with n = 10^4, α = 0.8, N = 10^6, use the released model to store and query, and empirically estimate P(fhat''_i - f_i ≥ εN) for ε = 0.01, 0.05, 0.1. Compare with (ε d2)^{-1}: if the empirical exceedance probability is larger than the claimed bound, Theorem 4.3 is false as stated; if smaller, report the empirical constant C and note the proof still needs correction.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The paper's headline theoretical contribution is the 'first error bound for neural sketch' in Theorem 4.3: P(|fhat''_i - f_i| ≥ εN) ≤ (ε d2)^{-1}. The proof in Appendix G writes the error as bounded by the average over d1 hash rows of Σ_j I_{i,j,k} f_j (v_j^k / v_i^k), then asserts E[fhat'' - f_i] ≤ N/d2. This step implicitly requires E[v_j^k / v_i^k] ≤ 1 for each pair of distinct items. However, under the paper's own Theorem 4.1, v_i^k and v_j^k are independent and identically distributed across items (the embedding hash functions are independent). For positive i.i.d. X, Y, E[X/Y] = E[X] E[1/Y], and by Jensen's inequality E[1/Y] ≥ 1/E[Y], so E[X/Y] ≥ E[X]/E[Y] = 1, with strict inequality whenever Y has any variance. The learned V is not constant (Appendix C constrains entries to [ε, 1] with ε = 0.001, and the ablation shows the learnable V matters), so E[v_j^k / v_i^k] is strictly greater than 1. Consequently, the Markov step can only yield P(fhat''_i - f_i ≥ εN) ≤ C/(ε d2) with C = E[v_j^k / v_i^k] > 1, not the stated 1/(ε d2). The claimed bound is therefore not derived. This is a concrete mathematical flaw in a central claimed contribution, distinct from the heuristic distributional assumptions in Theorem 4.2. The bound is also vacuous for ε ≤ 1/d2, but for small ε it makes a strong quantitative claim that the proof does not support.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper introduces the Lego Sketch, a memory-augmented neural network (MANN) for estimating item frequencies in data streams. Its architecture combines (i) a normalized multi-hash embedding that maps any item to an L1-normalized vector using a learnable table and d1 hash functions, (ii) a scalable memory organized as K hash-distributed bricks so the space budget can be changed by adding bricks without retraining, (iii) a DeepSets-based memory-scanning module that reconstructs global stream characteristics (item count n and skewness α) from a subset of a memory brick, and (iv) an ensemble decoder that blends a neural prediction with the rule-based estimate min(m_i / v_i), gated on reconstructed skewness. Training is self-supervised meta-learning on synthetic Zipf streams with a self-guided loss that weights task errors by the inverse of the rule-based error. The paper claims domain-agnostic scalability (Theorem 4.1), memory scalability via a sub-skewness analysis (Theorem 4.2), and what it calls the first error bound for a neural sketch (Theorem 4.3). Experiments cover four real datasets (Lkml, Kosarak, Wiki, Webdocs; the Aol dataset was removed because of its anonymization flaw) and six synthetic Zipf streams, with CMS, CS, LCS, meta-sketch, and a D-Lego derivative as baselines, plus ablations and throughput measurements. Code is provided.","tokens_in":17603,"tokens_out":25287,"duration_ms":223439,"significance":"The paper addresses a genuine limitation of earlier neural sketches — retraining when the domain or space budget changes — and the modular brick design is a credible engineering response. The empirical evaluation is broad (four real and six synthetic streams, several baseline families, ablations, and throughput), the reported results are consistent in direction, and the code is released. If the empirical claims hold, this is a useful practical contribution to learned data structures. The theoretical part is the weak point: Theorem 4.3, advertised as the first error bound for a neural sketch, relies on an unproven expectation step that is false for non-constant positive embeddings, so the stated constant is not established; Theorem 4.2 is a heuristic presented as a theorem; and the experiments report no variance information despite stochastic training. All of these are repairable within the manuscript's scope, but the current text overstates what is guaranteed.","major_comments":[{"comment":"Theorem 4.3 states P(|f''_i - f_i| ≥ εN) ≤ (ε d2)^{-1}, and the proof in Appendix G derives this via E[f''_i - f_i] ≤ N/d2. The step from the collision sum to N/d2 requires E[v_j^k / v_i^k] ≤ 1, which is asserted with no justification. Under the paper's own setup this is false: by the proof of Theorem 4.1, v_j^k and v_i^k are independent and identically distributed for distinct items i, j; Appendix C constrains V to [ε, 1] with ε = 0.001; and the ablation in Section 5.5 shows the learned V matters, so the marginal distribution is non-degenerate. For positive i.i.d. X, Y, Jensen's inequality gives E[X/Y] = E[X]E[1/Y] ≥ 1, with strict inequality whenever Y is non-constant, so E[v_j^k / v_i^k] > 1. The Markov step therefore yields only P(f''_i - f_i ≥ εN) ≤ C/(ε d2) with C = E[v_j^k / v_i^k] > 1, not the stated 1/(ε d2). Because the 'first error bound for neural sketch' claim and the comparison in Section 4.3 rest on this constant, the theorem must be restated with an explicit and validated constant (or a genuine bound on C derived from the constraint set), and the proof corrected. It should also be stated that the bound concerns the rule-based fallback branch of Algorithm 2, not the neural prediction f'_i.","section":"§4.3 / Appendix G"},{"comment":"Theorem 4.2 is presented as a guarantee that the sub-stream skewness α' approximates the global skewness α, and the abstract says the analysis 'guarantees' high scalability. The proof is heuristic: the two distributional assumptions D ~ Geometric(1/K) and (r_i - r'_i) ~ NB(r'_i, 1/K) are asserted with only a Bernoulli-process intuition and no derivation; the negative-binomial parameter is off by one relative to the usual 'failures before r'_i - 1 successes' reading (which would give NB(r'_i - 1, 1/K)); and the key conclusion that α' ≈ α outside the top items is supported only by the numerical simulation in Figure 5, not by the stated formula. The formula is the local log-log slope between two points of a Zipf distribution; it does not by itself deliver the transfer claim used to justify multi-brick scaling. I recommend re-framing Section 4.2 as a heuristic/empirical analysis with explicit conditions and tempering the 'guarantees' language, or supplying genuine derivations of the distributional claims and a bound on the approximation error.","section":"§4.2 / Appendix F"},{"comment":"Section 5.1 states that the Aol dataset was excluded from experiments and ablations because reviewers identified its anonymization flaw, yet Figure 2, the introduction's motivating space-accuracy plot, carries the caption 'Space-accuracy Trade-off (Aol Dataset)', and Table 2 still lists Aol's statistics (n = 197,790, N = 361,115). The paper's motivating figure is therefore based on data the authors themselves exclude, contradicting their own disclosure. This must be resolved — replace Figure 2 with valid datasets and remove Aol from Table 2 and the surrounding discussion. Given the well-known privacy problems of the AOL search-log release, the current state of the manuscript also raises a data-ethics issue that the authors should address explicitly.","section":"§5.1, Figure 2, Table 2"},{"comment":"All experimental results in Figures 6–9 are reported as single runs, with no error bars, no numbers of seeds, and no significance tests. Since both the Lego Sketch and the meta-sketch baseline involve stochastic meta-learning, the strength of claims such as 'the ARE of the Lego sketch is only 85% of the error of MS' (Section 5.2) cannot be assessed. At minimum, the key comparisons (real datasets at representative budgets, the robustness sweep, and the four ablations) should be rerun over several seeds and reported as mean ± standard deviation with the seed count stated.","section":"§5.1–§5.5, Figures 6–9"}],"minor_comments":[{"comment":"The proof of Theorem 4.1 states P[v'_ij = V_k] = 1/d1, but since the learnable table V has dimension 80 (Appendix C) and each hash function H_j maps to one index of V, the probability should be 1/80; the text should be corrected for consistency.","section":"Appendix E"},{"comment":"The sentence 'The above analysis shows a wider margin compared to handcrafted sketch boundaries' is vague, since the stated bound has the same functional form as the classic Count-Min bound; the comparison should be made precise and any difference in constants quantified.","section":"§4.3"},{"comment":"The space budget B counts only the K memory bricks; the parameters of V, gscan, and gdec are not included, and at the smallest budget (0.6 MB) the fixed model overhead may be a material fraction of the footprint, so the accounting should be stated explicitly and the model size quantified.","section":"§5.1"},{"comment":"The gating condition uses I_α, but this skewness interval is never defined in the main text; it should be defined (presumably the training range [0.5, 1.0]) and its role in selecting the neural versus rule-based branch explained.","section":"Algorithm 2"},{"comment":"The self-guided loss weights the neural error by the inverse of the rule-based error produced by the same model; since f' and f'' share inputs, the guide is not independent of the learner, and a brief discussion of possible feedback effects during training would strengthen the presentation, even though the ablation in §5.5 shows an empirical benefit.","section":"§3.2"},{"comment":"The scalable memory is said to supplement m_i with a counting bucket carrying the sub-stream length, but this is not formalized in the memory model or in the proof of Theorem 4.3; please specify how this term enters the estimate f'' and the analysis.","section":"§3.1"},{"comment":"Since stores and queries are routed by H(x_i) to a single brick, the collision sum for K bricks is over a sub-stream of total frequency ≈ N/K, which would give the stronger bound 1/(ε K d2); the theorem should either state this or explicitly restrict itself to the single-brick training configuration.","section":"§4.3 / Theorem 4.3"},{"comment":"Minor typos should be fixed: 'dedicate creations' in the Figure 3 caption, 'theLego sketch' in the abstract, a missing subscript in 'In is set within [1000,50000]' in Appendix C, and 'pascal distribution' in Appendix F.","section":"Throughout"}],"recommendation":"major_revision","confidential_remarks":"The empirical contribution is the strongest part of this submission, and the theoretical problems identified in the major comments are repairable, so I recommend major revision rather than rejection. Two points deserve editorial attention: (1) the residual Aol material (Figure 2 and Table 2) contradicts the authors' own exclusion statement in Section 5.1 and should be resolved before further review, and (2) the unproven expectation step in Theorem 4.3 is the kind of error that can slip through because the appendix proof reads plausibly; I would ask the authors to provide the corrected constant explicitly. Separately, the manuscript header identifies this as ICML 2025 published proceedings; if the target journal's policy excludes prior-conference work, that is an editorial matter to consider as well."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Short version: this is a genuinely new neural sketch architecture with strong empirical results across real and synthetic streams, but the headline theoretical contribution—the 'first error bound for neural sketch'—has a gap in the proof that I think is real. The core empirical claim probably survives; the theory needs work.\n\nWhat's new: the combination of normalized multi-hash embedding, multi-brick memory with a single trained brick, Deep Sets scanning, and a self-guided loss is not in prior work. The scalability story—train once on one brick, deploy at 100KB to 140MB—is practically useful, and the experiments back it up across five domains. The ablation study gives credit to each module, which is more than most papers do. Code is available.\n\nThe soft spots are mostly in Section 4. Theorem 4.2's sub-stream skewness argument rests on geometric/negative-binomial assumptions that are heuristics; the numerical simulation in Figure 5 is suggestive but not a proof. That's a moderate concern. The bigger issue is Theorem 4.3. The proof in Appendix G needs E[v_j^k / v_i^k] ≤ 1, but v_i^k and v_j^k are i.i.d. positive (by Theorem 4.1), and for positive i.i.d. variables E[X/Y] ≥ 1 by Jensen, strict when there's any variance. Since V is learnable and entries are in [ε,1], variance is essentially guaranteed. So the Markov step can only give a constant C/(ε d2) with C > 1, not the stated 1/(ε d2). The stress-test note is correct: the claimed bound as stated is not derived. Also, the bound is vacuous for ε ≤ 1/d2, but that's a minor point. The empirical comparison would be stronger with error bars and multiple seeds; the AOL removal is disclosed and understandable, but it is a post-hoc change.\n\nOverall, I think the paper is worth engaging with. The architecture is a real step beyond meta-sketch, and the multi-brick scaling idea is worth testing in other settings. The theory should not be a condition for acceptance as written. A serious referee should spend time on Appendix G and either fix the constant or restate the theorem as an asymptotic or expected bound. If the authors can do that, the paper is a solid ICML-style contribution.\n\nMy recommendation: send to peer review, but the reviewer should treat the theoretical claims skeptically and the empirical claims as preliminary until more seeds are shown.","headline":"A genuinely new neural sketch architecture with strong empirical results, but the paper's headline error bound has a concrete proof gap and the scalability theorem is heuristic.","tokens_in":18127,"tokens_out":2418,"would_cite":true,"duration_ms":21304,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"The Lego sketch is a memory-augmented neural network that scales one trained model across space budgets from 100KB to 140MB and across data domains without retraining.","keywords":["frequency estimation","data stream sketching","memory-augmented neural networks","neural sketches","Zipf distribution","scalable memory","meta-learning","normalized hash embedding"],"falsifier":"On a synthetic Zipf stream with known $\\alpha$, hash items into $K$ bricks and directly estimate the sub-skewness $\\alpha'$ inside each brick; if $\\alpha'$ deviates from $\\alpha$ for items beyond rank 10 by more than the paper's simulation suggests, the transfer premise fails. A behavioral test is to train the model at $K=1$, evaluate at $K=64$ on a stream whose bricks have been deliberately imbalanced (for example, hashing only the highest-frequency items into one brick), and check whether the average relative error on that brick degrades sharply.","tokens_in":16936,"feed_emoji":"🧱","tokens_out":11529,"duration_ms":69779,"temperature":0.7,"pith_summary":"This paper sets out to show that a neural sketch for frequency estimation in data streams can be made scalable, instead of being retrained whenever the data domain or the space budget changes. It proposes the Lego sketch, a memory-augmented network built from modular memory bricks: items are hashed into sub-streams, each brick stores one sub-stream, and adding bricks enlarges memory. The authors claim that because the embedding is hash-based and L1-normalized, its distribution is the same across all domains, and because each brick sees a sub-stream with nearly the same Zipf skewness as the full stream, a model trained on one brick transfers to any number of bricks. If these claims hold, a single trained sketch can be resized from 100KB to 140MB and deployed on unrelated stream domains without retraining, while lowering average absolute and relative error compared with handcrafted and existing neural sketches.","feed_headline":"Lego sketch scales one trained model from 100KB to 140MB","feed_subtitle":"Modular memory bricks let one trained model resize and change domains without retraining, beating classic sketches.","key_machinery":"The load-bearing mechanism is the pairing of a normalized multi-hash embedding with hash-distributed scalable memory. The embedding looks up $d_1$ entries of one learnable vector through hash functions and L1-normalizes the result, which is what makes the embedding distribution domain-invariant; the memory manager then hashes each item into one of $K$ bricks, each a replica of the trained single-brick module, so the total space is $K$ times one brick and no retraining is needed when $K$ changes. Two supporting components carry the accuracy argument: a Deep Sets-based memory-scanning module that reads one tenth of a brick to reconstruct stream characteristics such as item count and Zipf skewness, and a self-guided weighting loss that reweights each meta-task's errors by the error of a rule-based estimate $\\hat{f}_i'' = \\min(m_i / v_i)$.","core_discovery":"The central claim is that a neural sketch's two scalability failures—domain shift and memory resizing—can be solved simultaneously by replacing the domain-specific learned embedding with a normalized multi-hash embedding and replacing the fixed dense memory with $K$ hash-partitioned memory bricks. Theorem 4.1 says the normalized embedding vectors follow the same distribution for every data domain; Theorem 4.2 gives a transfer formula showing that the sub-skewness $\\alpha'$ inside each brick approximates the global skewness $\\alpha$ once the top few items are excluded, so the scanner and decoder trained on one brick carry over to many bricks; Theorem 4.3 gives the first error bound for a neural sketch, $P(|\\hat{f}_i'' - f_i| \\ge \\epsilon N) \\le (\\epsilon d_2)^{-1}$, for the rule-based estimate, where $d_2$ is the number of address slots in each row of a brick. On top of this scaffolding, the architecture adds a memory-scanning module that reconstructs global stream statistics from a subset of a brick and a self-guided weighting loss that uses the rule-based estimate as a guide during meta-training. The paper reports that the resulting Lego sketch lowers average absolute and relative error relative to count-min, count, learned count, and meta-sketch across five real datasets and synthetic Zipf streams, with memory resized over a 1400-fold range.","pith_inferences":["A testable extension beyond this paper: the 'train on one shard, hash into $K$ shards, transfer' recipe should apply to other learned data structures whose training depends only on frequency ranks, such as learned Bloom filters or graph stream summaries, since Theorems 4.1 and 4.2 do not rely on domain-specific features.","The self-guided loss suggests a general meta-learning trick: when a cheap rule-based baseline exists inside a model, reweighting each meta-task's errors by that baseline's error can push the neural estimator to beat the baseline at large budgets, a recipe that could be lifted out of sketching entirely.","If the scanning module genuinely recovers $n$ and $\\alpha$ from one tenth of a brick, it could serve as a lightweight stream-profiling tool that reports distributional statistics without maintaining separate counters.","The memory-scaling argument assumes hash-uniform distribution of items across bricks; in adversarial settings where an attacker controls item-to-hash mappings, per-brick skewness could diverge, so random seed refresh or robust hashing may be needed before the 140MB scaling claim is used in security-sensitive deployments."],"forward_implications":["A single pretrained Lego sketch can serve any space budget that is a multiple of one brick, from a 100KB brick up to 140MB, without retraining.","Because the embedding distribution is domain-invariant, the same trained model transfers to new stream domains, as demonstrated on five real datasets spanning word, communication, click, edit, and document streams.","Stream-level statistics such as the number of distinct items and the Zipf skewness can be recovered from compressed memory by the scanning module, giving the decoder information handcrafted sketches cannot easily access.","The rule-based estimate $\\hat{f}_i'' = \\min(m_i/v_i)$ carries a provable error bound, making the Lego sketch the first neural sketch with an error analysis rather than purely empirical accuracy.","Using the Lego sketch as the core of an elastic-style derivative (heavy-part filter plus Lego core) yields further error reduction, so the architecture can replace count-min and count cores inside existing derivative frameworks."],"supporting_citations":[{"why":"Supplies the count-min sketch baseline that Lego sketch must beat and the handcrafted error-bound standard Theorem 4.3 is compared with.","marker":"Cormode & Muthukrishnan, 2005"},{"why":"Supplies the C-sketch baseline and the min-ratio estimate form reused as the rule-based $\\hat{f}_i''$ in ensemble decoding.","marker":"Charikar et al., 2002"},{"why":"Provides the meta-sketch MANN baseline and the single-brick architecture and self-supervised meta-learning training scheme that Lego sketch extends.","marker":"Cao et al., 2023; 2024"},{"why":"Supplies the LCS learned baseline that uses prior knowledge of $n$, the closest non-orthogonal learned competitor.","marker":"Aamand et al., 2024"},{"why":"Provides the hash-embedding technique that normalized multi-hash embedding generalizes.","marker":"Tito Svenstrup et al., 2017"},{"why":"Supplies the permutation-invariant Deep Sets architecture used for the memory-scanning module.","marker":"Zaheer et al., 2017"},{"why":"Provides the elastic sketch derivative used as the D-CMS comparison for the D-Lego case study.","marker":"Yang et al., 2018"},{"why":"Provides the neural Bloom filter meta-learning approach whose training strategy the paper adopts.","marker":"Rae et al., 2019"}],"fun_headline_variants":["Lego sketch: one trained model spans 1400x memory","Modular memory bricks let one model resize and change domains","First error bound for neural sketches from Lego sketch","Lego sketch outperforms classic and neural sketches in accuracy","Lego sketch adapts without retraining across 1400x memory"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The scalability guarantee rests on the assumption that after items are hashed into $K$ memory bricks, the frequency distribution inside each brick has approximately the same shape as the whole stream except for a handful of top items, so the model trained on one brick transfers unchanged to all bricks.","fun_headline_variants_meta":{"raw":{"variants":["Lego sketch: one trained model spans 1400x memory","Modular memory bricks let one model resize and change domains","First error bound for neural sketches from Lego sketch","Lego sketch outperforms classic and neural sketches in accuracy","Lego sketch adapts without retraining across 1400x memory"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.001725,"raw_usage":{"total_tokens":6860,"prompt_tokens":1025,"completion_tokens":5835,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":641,"completion_tokens_details":{"reasoning_tokens":5751}},"tokens_in":641,"tokens_out":5835,"duration_ms":32968,"temperature":1.0,"reasoning_tokens":5751,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-07T14:11:12.245000+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"On a synthetic Zipf stream with known $\\alpha$, hash items into $K$ bricks and directly estimate the sub-skewness $\\alpha'$ inside each brick; if $\\alpha'$ deviates from $\\alpha$ for items beyond rank 10 by more than the paper's simulation suggests, the transfer premise fails. A behavioral test is to train the model at $K=1$, evaluate at $K=64$ on a stream whose bricks have been deliberately imbalanced (for example, hashing only the highest-frequency items into one brick), and check whether the average relative error on that brick degrades sharply.","supporting_citations":[{"cited_title":"and Muthukrishnan, S","cited_arxiv_id":null,"evidence_quote":"Supplies the count-min sketch baseline that Lego sketch must beat and the handcrafted error-bound standard Theorem 4.3 is compared with."},{"cited_title":"C., and Farach - Colton, M","cited_arxiv_id":null,"evidence_quote":"Supplies the C-sketch baseline and the min-ratio estimate form reused as the rule-based $\\hat{f}_i''$ in ensemble decoding."},{"cited_title":"Meta-sketch: A neural data structure for estimating item frequencies of data streams","cited_arxiv_id":null,"evidence_quote":"Provides the meta-sketch MANN baseline and the single-brick architecture and self-supervised meta-learning training scheme that Lego sketch extends."},{"cited_title":"Improved frequency estimation algorithms with and without predictions","cited_arxiv_id":null,"evidence_quote":"Supplies the LCS learned baseline that uses prior knowledge of $n$, the closest non-orthogonal learned competitor."},{"cited_title":"Hash embeddings for efficient word representations","cited_arxiv_id":null,"evidence_quote":"Provides the hash-embedding technique that normalized multi-hash embedding generalizes."},{"cited_title":"R., and Smola, A","cited_arxiv_id":null,"evidence_quote":"Supplies the permutation-invariant Deep Sets architecture used for the memory-scanning module."},{"cited_title":"Elastic sketch: Adaptive and fast network-wide measurements","cited_arxiv_id":null,"evidence_quote":"Provides the elastic sketch derivative used as the D-CMS comparison for the D-Lego case study."},{"cited_title":"Meta-learning neural bloom filters","cited_arxiv_id":null,"evidence_quote":"Provides the neural Bloom filter meta-learning approach whose training strategy the paper adopts."}],"review_version":1}