{"id":"bdaf44e8-7fa1-4959-8b9c-c861d029bfa7","arxiv_id":"2607.20634","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":7.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":6,"one_line_summary":"A differentiable DSL combines multi-rate, recurrent, and cascade filter tricks; automated search and compilation produce Pareto-optimal fast filter programs that dominate prior baselines across six filter families.","lead":"This paper unifies known fast-filter tricks into one differentiable design language and automatically searches it to generate C++ programs that beat standard approximations on speed/quality trade-offs. The headline Gaussian speedup is 600x versus FFT, though the paper's own plots cap Gaussian speedups at roughly 70x versus the fastest exact method, separable convolution.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Fig. 1's '600x faster than the fastest exact filtering method' for a 2D Gaussian is contradicted by the paper's own statement that separable convolution is faster than FFT; recomputing against the separable baseline drops the speedup to ~70x.","rationale":"I focused on the 600x claim because it is the most concrete and internally checkable flaw in the paper's central narrative, and because it directly concerns the advertised magnitude of the improvement. The reader's own weakest assumption (Pareto-frontier completeness) is a legitimate methodological concern, but I do not think it is the most load-bearing: even an incomplete frontier can support the existence claim that the search found designs faster and at least as accurate as the baselines—missing even better designs would not refute that the reported designs dominate the baselines. The 600x inconsistency, by contrast, is a false quantitative statement in the paper's main figure, contradicted by the paper's own benchmark data. The paper has real strengths: the DSL unification, the differentiable TIIR parameterization, and the use of a common lowering system for both search designs and baselines are substantive contributions, and the reported Pareto plots are extensive. But the headline speedup needs correction. Since the reader already identified this issue and assigned CONDITIONAL, my read does not change the verdict; it reinforces the need for the correction and for release of code/data to verify the benchmark numbers.","tokens_in":55094,"tokens_out":8564,"duration_ms":72230,"concrete_test":"Recompute the speedup of the Fig. 1 design (PSNR 79 dB, 43819 MPix/sec) against the paper's own linearly separable 2D Gaussian benchmark on the same CPU (AMD 9800X3D, cache-resident 4 MP input). If the speedup is about 70x rather than 600x, the headline is overstated and should be corrected. Also audit all reported speedups in the text and tables (e.g., Tables 3–4, Section 4.6) to confirm which exact baseline was used; any speedup stated as relative to 'the fastest exact method' must be relative to separable convolution for 2D Gaussians, not FFT.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The headline quantitative claim is internally inconsistent. The Fig. 1 caption and Section 1 state that an approximation to a Gaussian blur with radius 200 runs '600 times faster than the fastest exact filtering method,' and the same caption explicitly ties this to FFT-based convolution. However, Section 4.6 states that for 2D Gaussians 'linearly separable convolution is faster' than FFT, and the text reports a maximum speedup of 70.2x over separable convolution (Section 4.6, size 401). Thus the 600x figure appears to be measured against FFT, not the fastest exact method. This is not a cosmetic caption issue: it inflates the advertised speedup by roughly 8.5x and makes Fig. 1's comparison misleading, since the 'Separable' curve is the relevant exact baseline. The underlying claim that search finds designs faster than CP/FRM/triple-box may still be defensible, but the central numerical headline of the paper is not supported by the paper's own benchmark data.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper presents a DSL for fast FIR approximations whose primitives unify multi-rate filtering, tail-canceling IIRs, cascades/sums, and stride/interpolation. Search enumerates program structures, fits continuous parameters with gradient descent (including a reparameterization for TIIRs), uses a cost model to rank designs, then lowers top designs to optimized C++ (SIMD, tiling, fusion). Evaluation covers 1D Gaussian, Lanczos, HRIR, and telephone filters, and 2D Gaussian, Gabor, and low-pass filters, reporting Pareto frontiers against CP, FRM, triple-box, YVV, and SVD baselines, plus exact FFT/direct/separable methods.","tokens_in":55302,"tokens_out":7789,"duration_ms":68082,"significance":"If the results hold, this is a substantial systems contribution: the DSL subsumes CP and FRM, the differentiable TIIR parameterization is a useful technical building block, and the automatic lowering to fast C++ addresses a real gap in prior approximate-filtering work. The evaluation is extensive, includes qualitative outputs, and is often conservative (e.g., overestimating YVV throughput for Gabors). The central search-and-lowering pipeline is coherent, and the claimed dominance over the investigated baselines is credible. However, the headline 600x speedup in Fig. 1 is not supported as stated, and the completeness of the reported Pareto frontier is conditional on cost-model rankings that are not independently validated.","major_comments":[{"comment":"The headline claim that the Gaussian approximation runs '600 times faster than the fastest exact filtering method' is internally inconsistent. Section 4.6 explicitly states that for 2D Gaussians 'linearly separable convolution is faster' than FFT, and Fig. 38 reports a maximum speedup of 68.6x over that separable baseline for size 401. Thus 600x is measured against FFT convolution, not the fastest exact method. This is not a cosmetic caption issue: it inflates the advertised speedup by roughly 8.5x. Please correct the caption/text to say '600x faster than FFT convolution' or, preferably, report speedups against the actual fastest exact baseline (separable convolution), which yields ~70x.","section":"Fig. 1; §4.6; Fig. 38"},{"comment":"The paper's 'Pareto frontier' is computed after pruning by enumeration constraints (Appendix 7.2) and by a cost model (Section 3.3) that ranks 150k designs and keeps only the top 3 tiers (2,500 designs) for benchmarking. The cost model has 0.97–0.98 log-log correlation, but no validation is provided that the cost model or the enumeration rules do not discard designs that would actually lie on the true frontier. Since the abstract and Section 3 claim to 'generate a Pareto frontier,' the paper should soften this wording to 'frontier over sampled/ranked designs' or add a validation experiment (e.g., benchmarking a random sample of lower-tier and pruned designs) to demonstrate that no Pareto-optimal designs are systematically excluded.","section":"§3.3; §7.2"}],"minor_comments":[{"comment":"Typo: 'one our programs' should be 'one of our programs.' Also, the caption should specify which exact method the 600x figure refers to.","section":"Fig. 1 caption"},{"comment":"The text reports correlation coefficients 0.98 (1D) and 0.97 (2D), but Fig. 17 labels them as r=0.97 (1D) and r=0.98 (2D). The numbers are swapped and should be corrected.","section":"§3.3 vs Fig. 17"},{"comment":"Typo: 'PSNR 61.dB' should be 'PSNR 61.4dB' or similar.","section":"§4.8"},{"comment":"The first data row 'Ours 1 1.96 21.94 46.97' is misaligned and confusing; align the columns and clarify the row labels.","section":"Table 4"},{"comment":"Capitalization of 'DownUpSample' vs. 'DownUpsample' is inconsistent throughout the manuscript and appendix; unify the notation.","section":"§7.4"},{"comment":"The paper would benefit from an artifact/reproducibility statement, including whether code and benchmark scripts will be released.","section":"General"}],"recommendation":"major_revision","confidential_remarks":"This is a strong systems paper with a coherent technical core. The main issue is the misleading headline speedup, which should be corrected before publication. The cost-model completeness concern is common in search-based systems and can be addressed either by more cautious wording or by a targeted validation experiment. The paper fits the journal's scope and the underlying contribution is significant."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Two things worth knowing. First, this is a real contribution: a differentiable DSL that unifies multi-rate filtering, TIIRs, FIR/cascade/sum decompositions, plus automated search and lowering to fast SIMD C++. That is more than a routine extension of prior work. Second, the paper's own headline does not hold up internally. Fig. 1's claim that a 2D Gaussian runs \"600 times faster than the fastest exact filtering method\" is contradicted by Section 4.6, which says for 2D Gaussians linearly separable convolution is faster than FFT, and reports a 70.2x speedup over that baseline. The stress-test note is right: the advertised number is about 8.5x too optimistic.\n\nWhat is genuinely good: the differentiable TIIR parameterization via time-step rescaling seems well-motivated and the derivations in Section 3.4.2 are coherent. The enumeration constraints, term-rewriting normalization, and lowering passes are described with unusual care. The benchmarks are extensive, with impulse/frequency response plots and concrete discovered structures. The authors also handle the obvious circularity concern responsibly: CP and FRM are in their DSL by construction, so beating those baselines is a within-system comparison, not a proof of frontier optimality, and they do not oversell it as such.\n\nThe soft spots are mostly addressable. No code or data is released, which makes the reported Pareto frontier hard to reproduce. There are no error bars on throughput measurements. The search prunes 150k designs to 2,500 based on a cost model with 0.97–0.98 correlation, so the final frontier is conditional on that model not discarding something good. The headline inconsistency is the most concrete problem and should be fixed by reporting speedups against the true fastest exact baseline consistently. Two minor points: the YVV comparison for Gabors is admittedly an over-estimate, and several hyperparameters look hand-tuned, which further argues for artifacts.\n\nThe citation pattern looks fine: it engages Wang and Smith, Lim, Farbman et al., Young–van Vliet, and Parhi–Messerschmitt without inflated self-citation. This paper is for people working on real-time filtering in imaging and audio, and for readers interested in domain-specific program search. It deserves a serious referee, but the revision needs to reconcile the headline number with its own benchmark section and ideally release the system or a benchmark harness.","headline":"A genuinely useful synthesis-and-search system for fast filter approximations, with a real headline-number inconsistency the authors need to fix before it can be taken at face value.","tokens_in":55857,"tokens_out":2408,"would_cite":true,"duration_ms":25096,"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":"This paper claims that most known tricks for speeding up large FIR filters compose into one searchable design language, and that automatically searching it yields approximations that are both faster and more accurate than hand-tuned methods","keywords":["filter approximation","program synthesis","Pareto frontier","tail-canceling IIR","multi-rate filtering","gradient descent","image processing","audio processing"],"falsifier":"Compile and benchmark all ~150k sampled designs for one target (e.g., 2D Gaussian size 201) instead of only the top-3 Pareto tiers. If any unbenchmarked design beats every published frontier point in throughput at equal or higher PSNR, the cost-model pruning is the limiting factor and the reported frontier is incomplete. A second test: run the identical pipeline on a held-out filter family not used in the paper, such as a sharp band-pass with 60 dB stopband attenuation, and check whether any generated design exceeds FFT throughput at PSNR above 50 dB; failure would mean the search's breadth do","tokens_in":54889,"feed_emoji":"⚡","tokens_out":8300,"duration_ms":65306,"temperature":0.7,"pith_summary":"The paper's central claim is that the familiar cost-saving techniques for large FIR filters — multi-rate down/upsampling, recursive IIR and tail-canceling TIIR filters, frequency-response masking with strided FIRs, and composition by cascade and sum — are all instances of one design language. Given a target filter, the system enumerates tree-structured programs in this language, fits their continuous parameters with gradient descent, predicts throughput with a cost model, and compiles the top designs to optimized vectorized parallel C++. Against Gaussians, Lanczos, head-related impulse responses, telephone effects, Gabors, and low-pass filters, the search produces approximations that match exact filtering while running tens to hundreds of times faster than FFT convolution, and it Pareto-dominates the prior methods (convolution pyramids, frequency-response masking, triple-box blur, YVV, rank-2 SVD) when those are implemented with the same compiler. If correct, this turns filter acceleration from hand-derived designs into automated search over a structured program space that spans imaging and audio.","feed_headline":"Search yields blur filters 600x faster than FFT","feed_subtitle":"Automated search beats hand-tuned approximations and reproduces known fast-filter methods as special cases.","key_machinery":"The load-bearing object is a small domain-specific language whose primitives are composable filter programs: FIR (dense finite impulse response), TIIR (tail-canceling IIR — a recursive filter plus a sparse FIR correction that truncates an infinitely long impulse response after N steps at O(1) cost per output), Stride (a strided child computation followed by a factored-tower interpolator, generalizing frequency-response masking), DownUpsampleI/II (prefilter, subsample, child, zero-upsample, interpolate), and binary combinators Cascade, Sum, and Pipe that build 2D filters from 1D ones. The subtle piece is the differentiable TIIR parameterization: rather than differentiating through the recurre","core_discovery":"In the paper's own terms, the discovery is that fast filter approximation reduces to a differentiable program search: every well-known acceleration scheme is a composition of a small set of primitives — dense FIRs, tail-canceling IIRs (recursive filters whose infinite tail is canceled by a sparse correction, yielding a finite impulse response at near-constant cost), strided frequency-response-masking blocks, down/upsample wrappers, cascades, sums, and a pipe operator that promotes 1D filters to 2D. The system enumerates legal program trees under hand-written constraints informed by signal-processing intuition, fits each structure's continuous parameters by gradient descent (using a time-step","pith_inferences":["The one-time training cost per filter could be amortized if, as the paper hints, a trained design can be resized across a parameter family (e.g., Gaussians of different radii); that would make the approach practical for production filter libraries.","The reported dominance suggests that classical operation-count comparisons understate real gaps: on modern CPUs, vectorization, fusion, and memory locality matter as much as arithmetic count, a lesson likely to transfer to other signal-processing kernels.","Because the enumeration constraints are hand-written, the breadth of the method is only as general as those rules; a strong test is whether the same constraints—or a learned variant—transfer to targets far outside the tested set, such as very sharp band-pass filters or 3D convolution kernels.","The cost model's 0.97–0.98 correlation bounds how much of the true design space the frontier explores; benchmarking all sampled designs rather than the top 2,500 would reveal how many potentially better programs were pruned."],"forward_implications":["For large Gaussian blurs, the search finds approximations that are visually indistinguishable from ground truth while running up to about 600x faster than FFT convolution on cache-resident images.","The commonly used triple-box Gaussian approximation is Pareto-dominated: generated designs are 3.9–4.7x faster at equal or higher PSNR on 2D Gaussians.","For real-time audio, HRIR binaural processing is reported 2.37x faster than a 16k-sample FFT and 8.66x faster than a 256-sample FFT block, with output indistinguishable from exact filtering; a telephone effect filter is 2.74x faster than FFT.","For 2D low-pass filters that are not separable, generated approximations reach speedups up to about 613x over FFT for size 401.","Prior acceleration methods appear as special cases or points inside the same search space, so isolated hand designs for new filters are likely to be automatically rediscovered or beaten by search."],"fun_headline_variants":["Unifying fast-filter tricks into one searchable language","Automated search outperforms hand-tuned filter approximations","Fast filter design reduced to program search","Search finds 600x faster blur filters, beating FFT","One framework synthesizes fast filters from primitives"],"cache_read_input_tokens":2304,"weakest_assumption_plain":"The reported Pareto frontier is only as trustworthy as the hand-written enumeration rules plus the cost model, which ranked 150k sampled designs and benchmarked only 2.5k; if the cost model mispredicts a pruned structure's throughput, the true frontier may contain better designs the search never saw.","fun_headline_variants_meta":{"raw":{"variants":["Unifying fast-filter tricks into one searchable language","Automated search outperforms hand-tuned filter approximations","Fast filter design reduced to program search","Search finds 600x faster blur filters, beating FFT","One framework synthesizes fast filters from primitives"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000614,"raw_usage":{"total_tokens":2646,"prompt_tokens":652,"completion_tokens":1994,"prompt_tokens_details":{"cached_tokens":256},"prompt_cache_hit_tokens":256,"prompt_cache_miss_tokens":396,"completion_tokens_details":{"reasoning_tokens":1934}},"tokens_in":396,"tokens_out":1994,"duration_ms":23468,"temperature":1.0,"reasoning_tokens":1934,"cache_read_input_tokens":256,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-01T09:47:06.945055+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Compile and benchmark all ~150k sampled designs for one target (e.g., 2D Gaussian size 201) instead of only the top-3 Pareto tiers. If any unbenchmarked design beats every published frontier point in throughput at equal or higher PSNR, the cost-model pruning is the limiting factor and the reported frontier is incomplete. A second test: run the identical pipeline on a held-out filter family not used in the paper, such as a sharp band-pass with 60 dB stopband attenuation, and check whether any generated design exceeds FFT throughput at PSNR above 50 dB; failure would mean the search's breadth do","supporting_citations":[],"review_version":1}