{"id":"bdf0e5fd-ae10-4f89-bc54-411667f49002","arxiv_id":"2502.04093","paper_version":3,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":2,"one_line_summary":"IPComp is the first interpolation-based progressive lossy compressor that achieves high compression ratios, fast single-pass retrieval, and error-bounded progressive refinement.","lead":"A new compression method, IPComp, lets scientists retrieve coarse versions of large simulation data quickly and then refine them, while keeping errors within bounds. It combines interpolation-based prediction with bitplane coding and a loader that fetches the minimum data needed for each requested fidelity.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Theorem 1's error bound ignores boundary stencil amplification, so IPComp's error-bound guarantee and DP minimum-loading claim are not established for its actual interpolation predictor.","rationale":"The strongest claim is conditional on the error-bound guarantee for progressive retrieval, and that guarantee is Theorem 1 together with the DP loader. If the p constants in Theorem 1 are underestimates, the optimization in Section 5.2 minimizes loaded bytes subject to an invalid constraint, and the output can violate the user-specified error bound. This is not a stylistic issue: it would break a core advertised property. The experimental evaluation reports averages and specific datasets; it does not stress worst-case boundary conditions, so it cannot validate a hard L-infinity guarantee. I considered other candidate concerns: the abstract's '698% faster speed' conflicts with the 'around 300% faster' text in Section 6.2.3, and the reconstruction pseudocode in Algorithm 1 (lines 12-13) is at least confusing; both are real but secondary to the correctness of the error-bound claim. The reader's weakest_assumption already identified Theorem 1, and this review sharpens that to the missing boundary-norm condition. Releasing code with a boundary-aware theorem, or revising the constants to match the actual implementation, would resolve the concern.","tokens_in":18174,"tokens_out":10441,"duration_ms":113387,"concrete_test":"On a small 1D grid (n=16, 32, 64), construct the exact interpolation matrices P_l used by IPComp in linear and cubic modes, including its boundary handling, and compute the induced L-infinity norm of the composed propagation operator prod_{j=1}^{l} P_j for all l. If max_l ||prod_{j=1}^{l} P_j||_inf exceeds p^l with p as defined in Theorem 1, then Theorem 1's constants are invalid; confirm by retrieving a synthetic boundary-heavy signal at a requested error bound E and checking whether the actual L-infinity error exceeds E. If the computed norms equal p^l for all l and the synthetic retrieval stays below E, the concern is resolved.","verdict_should_be":"CONDITIONAL","load_bearing_attack":"The central claim that IPComp guarantees a user-specified L-infinity error during progressive retrieval rests on Theorem 1 (Eq. 5) and on the DP loader built on it (Section 5.2). Theorem 1 sets p=1 for linear interpolation and p=1.25 for cubic interpolation, with Eq. 9 converted to Eq. 5 by replacing each ||P_l||_inf by p. These constants come from the centered stencils in Eqs. (1)-(2). However, an interpolation-based compressor must define predictions at array boundaries, and one-sided or extrapolation boundary stencils can have absolute coefficient sums larger than p; for example, quadratic extrapolation coefficients (3,-3,1) have L-infinity norm 7. The paper never specifies the boundary rule or computes the induced norm of the boundary-inclusive predictor, and it simply asserts that errors amplify by p per level and that the maximum error occurs at the finest level. If the exact IPComp predictor has any boundary norm greater than p, then the per-level errors err(l,b_l)=p^(l-1)||delta_y_l||_inf used in Section 5.2 underestimate the true propagated error, the knapsack objective can choose a loading plan whose actual maximum error exceeds the requested bound E, and the advertised error-bounded progressive retrieval fails near boundaries. This is a worst-case guarantee issue, so average experimental errors or cancellation among levels cannot restore a hard error bound.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper presents IPComp, a progressive lossy compression framework built on interpolation-based prediction. It splits quantized prediction residuals into independent bitplanes, encodes them with a predictive/negabinary coder, and uses a dynamic-programming loader to select the minimum set of bitplanes per level under either an L-infinity error-bound constraint or a bitrate constraint. A theoretical bound (Theorem 1) is proposed to convert per-level bitplane truncation into an accumulated L-infinity error. Experiments on six datasets compare IPComp with SZ3-M, SZ3-R, ZFP-R, and PMGARD, reporting higher compression ratios, faster compression/decompression, and lower retrieval volume at equal fidelity.","tokens_in":18355,"tokens_out":7864,"duration_ms":84827,"significance":"If the central claims hold, IPComp is a meaningful step: it is the first interpolation-based progressive compressor with single-pass reconstruction, it supports arbitrary error bounds in retrieval, and the optimizer is lightweight. The evaluation spans four domains and six datasets, and the comparison includes both residual-based and multilevel baselines. The paper also gives a concrete error-propagation model with precomputed per-level truncation errors, which is a useful design contribution. However, the advertised guarantees depend on Theorem 1 and on the boundary behavior of the interpolation stencils; the current proof does not establish the worst-case bound for the implemented predictor. The performance claims also rest on single-run experiments without variance reporting.","major_comments":[{"comment":"The error-bound guarantee is not established for the actual predictor because the proof replaces each ||P_l||_inf by the centered-stencil constant p (p=1 or 1.25) without considering array boundaries. The stencils in Eqs. (1)-(2) are centered, but interpolation in a finite array must use one-sided or extrapolation stencils at boundaries; such stencils can have absolute coefficient sums larger than p (for example, quadratic extrapolation coefficients (3, -3, 1) have absolute sum 7). Unless the boundary rule is specified and its induced norm is included in Eq. (9), the per-level errors err(l,b_l)=p^(l-1)||delta_y_l||_inf used in Section 5.2 can underestimate the propagated error, and the DP solution may violate the requested error bound E near boundaries. The paper needs to either prove that the implemented boundary stencils have norm p, use a boundary-aware norm in Theorem 1, or handle boundaries with a conservative padding or error budget.","section":"5.1, Theorem 1, Eqs. (5)-(9)"},{"comment":"The comparison between transform and prediction models overgeneralizes from a single non-orthogonal example. Equation (3) is derived for the difference transform T with ||T^-1||_inf = n, and the text then concludes that errors in transform models are proportional to the input size. This is not true for orthogonal or near-orthogonal transforms such as the block transform in ZFP or the CDF 9/7 wavelet in SPERR, whose inverse L-infinity norms do not grow linearly with n. Since this comparison is used to motivate the choice of prediction over transform, it should be restated as an example rather than a general result, or replaced with a correct general bound.","section":"4.2, Eq. (3)"},{"comment":"The performance evaluation reports single runs without error bars, confidence intervals, or per-run variance. The headline claims (up to 487% higher compression ratio, 698% faster speed, and up to 83% reduced retrieval volume) are point estimates from one execution; on HPC nodes with variable clock frequency and system contention, this is insufficient support. Please report multiple runs and variability, and state the number of repeats. This is especially important for the speed comparisons in Figures 8-9, where timing differences can be dominated by system noise.","section":"6, Figures 5-10"}],"minor_comments":[{"comment":"The heading 'Introduction to none-progressive interpolation algorithm' contains a typo; it should be 'non-progressive'.","section":"4.1"},{"comment":"The abstract states that the solution 'archives up to 487%'; this should be 'achieves'.","section":"Abstract"},{"comment":"It is not stated how the entropy values are computed (empirical entropy of the encoded bitplane symbols after XOR, or a theoretical model). Please clarify the measurement so the reader can interpret the entropy reductions.","section":"Table 2"},{"comment":"The claim that the discrete error values fall within the range [128, 1023] by normalizing the retrieval bound E by the compression bound eb should be justified; it appears to assume a fixed 32-bit integer range and a specific bitplane truncation behavior that are not otherwise stated.","section":"5.2"}],"recommendation":"major_revision","confidential_remarks":"The paper is in scope for the venue and the core idea is promising. The boundary-stencil issue is the main technical obstacle and is fixable with a conservative norm or boundary padding. I would also urge the authors to provide the promised artifact and to include statistical detail for the performance claims. The related work is adequately cited and there is no novelty-disclosure concern."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Zhuoxun and colleagues have put together something the field has been missing: a progressive compressor built on interpolation prediction rather than residual stacking or multigrid transforms. The design is clear — multilevel interpolation prediction, independent bitplanes per level, and a DP-based loader that chooses which bitplanes to fetch to meet an error bound or bitrate target. The evaluation on six real datasets against SZ3-R, ZFP-R, PMGARD, and SZ3-M is the broad comparison that earns credibility. Reported gains in compression ratio and retrieval volume are consistent across datasets, and PSNR results are competitive. This is not a minor tweak; the combination of bitplane coding with interpolation prediction is new, and the error propagation analysis in Theorem 1 is a genuine attempt to formalize the behavior.\n\nThe weak spot is the theorem's reliance on the operator norm of the interpolation predictor. The p values 1 and 1.25 are computed from the interior stencils in Eqs. (1)-(2). The paper never specifies how boundary points are predicted. If the implementation uses one-sided stencils or extrapolation at boundaries, the induced L-infinity norm can be larger than those constants, and the guarantee in Eq. (5) may not hold for the exact predictor. That is a real gap. It may be fixable by either proving boundary handling keeps the norm bounded by p or by explicitly excluding boundaries from the progressive error bound. As written, the proof is not airtight.\n\nA few smaller points. The experiments are single runs, no error bars or variance; acceptable for a systems paper but worth noting. The abstract promises 698% speedup while Section 6 reports around 300%; harmless but sloppy. The transform-vs-prediction discussion in Section 4.2 uses a toy differencing transform to argue against transform models; that doesn't land for ZFP or wavelets, though it is not central to the IPComp design.\n\nOverall, the central claim is likely correct in practice: IPComp gives better progressive retrieval than residual-based methods on the tested data. But the theoretical guarantee needs a more careful treatment of boundaries before I'd call it solid. The paper deserves a serious referee, and I'd recommend sending it to review.","headline":"IPComp is a genuine advance in progressive lossy compression, but its error-bound proof leaves boundary handling unspecified, so the theoretical guarantee as stated is not airtight.","tokens_in":18988,"tokens_out":3582,"would_cite":true,"duration_ms":35105,"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":"IPComp makes interpolation-based prediction progressive, so a single compressed stream can be retrieved at any fidelity with a guaranteed error bound, and it outperforms existing progressive compressors by up to 487% in compression ratio…","keywords":["progressive lossy compression","interpolation prediction","bitplane coding","negabinary coding","error-bounded compression","scientific data reduction","progressive retrieval","knapsack optimization"],"falsifier":"Compress a one-dimensional signal with sharp boundary gradients using cubic interpolation, retrieve it repeatedly with only low-order bitplanes loaded, and compare the measured maximum pointwise error against the bound in Equation (5); any retrieval level where the measured error exceeds the bound shows the per-level additive-error assumption fails.","tokens_in":17905,"feed_emoji":"🗜️","tokens_out":7349,"duration_ms":68345,"temperature":0.7,"pith_summary":"This paper tries to establish that a leading class of scientific lossy compressors, those built on interpolation-based prediction, can be made progressive without sacrificing the compression ratios or speed that make them attractive. It describes IPComp, a compressor that splits each level's quantized prediction residuals into 32 independent bitplanes, so users can retrieve a coarse reconstruction from a few bitplanes and refine it by loading more. The authors prove an $L_\\infty$ error bound for partial bitplane loading and cast the choice of which bitplanes to load as a knapsack problem solvable with negligible overhead. On six real datasets from four domains, IPComp reports the smallest retrieval volume at a given error bound and the lowest error at a given bitrate among the compared progressive compressors, while needing only one decompression pass per request. If correct, this removes the main obstacle to practical progressive retrieval in scientific workflows: users no longer have to decompress full precision just to inspect or analyze a small region.","feed_headline":"Progressive lossy compression gets up to 487% higher ratios","feed_subtitle":"IPComp retrieves coarse-to-fine data in one pass, cutting loaded data by up to 83% at the same error bound.","key_machinery":"The central mechanism is the multi-level interpolation prediction model combined with bitplane-truncated quantization. IPComp decorrelates data level by level using linear or cubic interpolation, quantizes each level's prediction residual into 32-bit integers, and encodes the 32 bitplanes of each level independently. Loading only some bitplanes at each level yields a lower-fidelity reconstruction, and Theorem 1 bounds the resulting $L_\\infty$ error by $\\sum_{l=0}^{L-1} p^l \\|\\delta y_{l+1}\\|_\\infty + e_b$, where $p=1$ for linear and $p=1.25$ for cubic interpolation and $\\delta y_l$ is the information lost by skipping bitplanes at level $l$. This bound converts progressive retrieval into a knapsack optimization, solved by dynamic programming to minimize loaded data while satisfying a user-specified error bound or bitrate.","core_discovery":"The paper's central claim is that interpolation-based prediction, the decorrelation strategy that already leads non-progressive scientific compressors like SZ, can be made progressive by organizing quantized prediction residuals into independent bitplanes per multiresolution level. Because the interpolation operator has a bounded $L_\\infty$ norm ($p=1$ for linear, $p=1.25$ for cubic), the error caused by loading only some bitplanes propagates in a controlled way, and Theorem 1 bounds the total reconstruction error by a weighted sum of per-level truncation errors plus the base quantization error. On top of this, IPComp adds a predictive bitplane coder that XORs earlier bits to lower entropy, negabinary coding to keep sign-bit planes compressible near zero, and a knapsack-based optimizer that selects the minimum bitplanes to load under an error-bound or bitrate constraint. The authors report that this yields up to 487% higher compression ratios, up to 698% faster compression and decompression, up to 83% less retrieval data at the same error bound, and up to 99% lower error at the same bitrate than state-of-the-art progressive compressors, while supporting arbitrary fidelity requests with a single decompression pass.","pith_inferences":["Beyond the paper, Theorem 1's structure suggests a general recipe: any predictor with a bounded interpolation operator norm can be made progressive by bitplane truncation, and predictors with smaller per-level norms would tighten the retrieval error bound.","The knapsack formulation could be extended beyond $L_\\infty$ to rate-distortion objectives, such as minimizing $L_2$ error or a quantity-of-interest error under a retrieval budget, using the same dynamic-programming skeleton.","Negabinary coding's smaller truncation uncertainty, roughly two-thirds of sign-magnitude coding, may be attractive in other layered or embedded coding schemes, not only interpolation-based progressive compression.","The visualization result that Curl is usable at 0.3% retrieval while Laplace needs 1% suggests that application-specific quality thresholds could be used to auto-select the retrieval level, which IPComp's arbitrary-fidelity interface makes possible."],"forward_implications":["Users can request any error bound or bitrate and receive a reconstruction from a single decompression pass, eliminating the repeated passes that residual-based progressive compressors require.","For the same error bound, IPComp loads up to 83% less data than SZ3-R, ZFP-R, and PMGARD on the tested datasets.","At the same retrieval bitrate, IPComp achieves up to 99% lower reconstruction error, giving higher PSNR without additional storage.","Because IPComp preserves byte-level patterns better than Huffman-based SZ3, it can beat even the non-progressive SZ3 in compression ratio at high precision settings.","Residual-based progressive compressors slow down as the number of anchor error bounds increases, whereas IPComp's speed is independent of fidelity granularity."],"supporting_citations":[{"why":"Supplies the interpolation prediction formulas, linear and cubic, that IPComp makes progressive.","marker":"[35]"},{"why":"Defines the residual-based progressive framework used by the SZ3-R and ZFP-R baselines that IPComp improves upon.","marker":"[30]"},{"why":"Provides error-controlled progressive retrieval baselines, including SZ3-M and PMGARD, under derivable quantities of interest.","marker":"[34]"},{"why":"Introduces PMGARD, the multilevel-decomposition progressive compressor used as a baseline.","marker":"[23]"},{"why":"Supports the paper's claim that interpolation-based compression is one of the best methods for scientific data reduction.","marker":"[28]"},{"why":"Provides auto-tuned multi-component interpolation, additional evidence for the leading performance of interpolation decorrelation.","marker":"[29]"},{"why":"Supplies ZFP as a transform-based baseline and the negabinary fixed-rate coding idea reused for sign-bit planes.","marker":"[25]"},{"why":"Provides the multilevel decomposition theory underlying the orthogonal level construction and error-bounded prediction model.","marker":"[2]"}],"fun_headline_variants":["IPComp: 487% higher ratios and 698% faster progressive compression","Progressive compression cuts retrieval data by 83% at same error bound","First interpolation-based progressive compressor lowers error up to 99%","IPComp: one-pass coarse-to-fine progressive compression, 698% faster"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The whole error guarantee rests on the assumption that the extra error from skipping bitplanes at different refinement levels adds up in the worst case without cancelling, and that the coarsest refinement level always dominates the total error.","fun_headline_variants_meta":{"raw":{"variants":["IPComp: 487% higher ratios and 698% faster progressive compression","Progressive compression cuts retrieval data by 83% at same error bound","First interpolation-based progressive compressor lowers error up to 99%","IPComp: one-pass coarse-to-fine progressive compression, 698% faster"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000871,"raw_usage":{"total_tokens":3827,"prompt_tokens":1053,"completion_tokens":2774,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":669,"completion_tokens_details":{"reasoning_tokens":2706}},"tokens_in":669,"tokens_out":2774,"duration_ms":21716,"temperature":1.0,"reasoning_tokens":2706,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-08T23:34:06.172188+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Compress a one-dimensional signal with sharp boundary gradients using cubic interpolation, retrieve it repeatedly with only low-order bitplanes loaded, and compare the measured maximum pointwise error against the bound in Equation (5); any retrieval level where the measured error exceeds the bound shows the per-level additive-error assumption fails.","supporting_citations":[{"cited_title":"Tonellot, Zizhong Chen, and Franck Cappello","cited_arxiv_id":null,"evidence_quote":"Supplies the interpolation prediction formulas, linear and cubic, that IPComp makes progressive."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Supplies ZFP as a transform-based baseline and the negabinary fixed-rate coding idea reused for sign-bit planes."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Provides the multilevel decomposition theory underlying the orthogonal level construction and error-bounded prediction model."}],"review_version":1}