{"id":"e56583b7-3b92-4d09-9f07-21a0cb438fa3","arxiv_id":"2606.00601","paper_version":1,"verdict":"UNVERDICTED","confidence":"LOW","novelty_score":7.0,"correctness_risk":"unknown","formal_verification":"none","parameter_count":0,"one_line_summary":"ScanWeaver lowers affine recurrences to compiler-generated Blelloch scans in MLIR, producing executable GPU code validated on selective-scan workloads against PyTorch, CUDA, and Mamba baselines.","lead":"ScanWeaver is a compiler framework that rewrites input-dependent recurrences such as Mamba selective scans into associative forms and lowers them through MLIR to parallel Blelloch scans on GPUs. A smart generalist might read it to understand how compilers can automate parallel execution for a growing class of sequential ML workloads without hand-written kernels.","discovery_kind":"new_method","skeptic_critique":{"model":"grok-4.3","headline":"Semantics preservation for general affine recurrences rests on unshown equivalence for non-Mamba forms","rationale":"The reader's weakest assumption is exactly the load-bearing point; the qualifier \"matched local recurrence semantics\" in the abstract supplies concrete textual evidence that generality is not yet demonstrated. Because the paper reports actual GPU execution, the concern is narrow and testable rather than fatal.","tokens_in":1714,"tokens_out":322,"duration_ms":16788,"concrete_test":"From the full paper, extract the precise syntactic definition of the supported affine recurrence class (§ on affine recurrences) and the decomposition rewrite rules; apply them to a 4-step recurrence with input-dependent coefficients outside the Mamba (A_t, B_t) pattern (e.g., h_t = (A_t * h_{t-1} + B_t) * C_t); compare the scan output against a direct sequential implementation on the same inputs; divergence > machine epsilon falsifies exact preservation.","verdict_should_be":"CONDITIONAL","load_bearing_attack":"The central claim requires that arbitrary affine recurrences (input-dependent linear recurrences beyond the Mamba selective scan) can be decomposed into associative operators whose Blelloch scan yields bit-for-bit identical results to the original sequential recurrence. The abstract only reports validation \"across forward selective-scan workloads with matched local recurrence semantics,\" which leaves open whether the decomposition rules are equivalence-preserving in general or only succeed when the local recurrence already matches the target associative form. No formal argument, inductive proof, or counter-example search is referenced in the provided text.","agreement_with_reader":"agree"},"referee_report":{"model":"grok-4.3","summary":"The paper presents ScanWeaver, a compiler framework that transforms recurrence-based computations (using Mamba-style selective scans as a motivating example of a broader class of affine recurrences) into associative scan representations. It performs end-to-end MLIR-based lowering to compiler-generated Blelloch scan execution on GPUs, with validation of decomposition, lowering, and actual GPU execution across forward selective-scan workloads that have matched local recurrence semantics, plus benchmarks against PyTorch, CUDA, and Mamba baselines.","tokens_in":1830,"tokens_out":349,"duration_ms":14954,"significance":"If the central claim of semantics-preserving decomposition and lowering holds for the targeted class, the work would provide a systematic compiler-driven path to parallelize input-dependent linear recurrences in ML workloads on GPUs. The end-to-end lowering to executable MLIR artifacts and actual GPU execution is a concrete strength.","major_comments":[{"comment":"Abstract: the validation is described only as covering 'forward selective-scan workloads with matched local recurrence semantics,' with no quantitative results, error analysis, or details on equivalence checking. This leaves the central claim of general affine recurrence decomposition only partially supported.","section":"Abstract"},{"comment":"The manuscript provides no formal argument, inductive proof, or counter-example analysis establishing that the decomposition rules yield bit-for-bit identical results for arbitrary affine recurrences (beyond cases where the local recurrence already matches the target associative form). This is load-bearing for the claim that ScanWeaver handles a 'broader class of affine recurrences.'","section":"Abstract (validation description)"}],"minor_comments":[],"recommendation":"major_revision","confidential_remarks":null},"author_rebuttal":{"model":"grok-4.3","summary":"We thank the referee for the feedback on the abstract and validation claims. We address the points regarding quantitative support and formal guarantees for the decomposition, clarifying the manuscript's empirical focus while acknowledging limitations in formal arguments.","responses":[{"response":"The abstract intentionally scopes the validation to workloads with matched local recurrence semantics to emphasize that equivalence holds by construction of the decomposition rules. Quantitative performance results, including speedups over PyTorch and CUDA baselines and comparisons to the Mamba kernel, appear in the evaluation section. Equivalence is confirmed via end-to-end GPU execution producing matching outputs. We will revise the abstract to explicitly reference the evaluation section and note the empirical equivalence checks performed.","revision_made":"partial","referee_comment":"[Abstract] Abstract: the validation is described only as covering 'forward selective-scan workloads with matched local recurrence semantics,' with no quantitative results, error analysis, or details on equivalence checking. This leaves the central claim of general affine recurrence decomposition only partially supported."},{"response":"The decomposition rules target the class of affine recurrences arising in ML workloads (exemplified by selective scans) that admit lowering to associative form; the 'matched local recurrence semantics' qualifier denotes precisely those cases where the rules apply and preserve semantics. The manuscript presents the rules with their rationale but does not include a formal inductive proof or exhaustive counter-example analysis, relying instead on the compiler implementation and empirical validation on representative workloads.","revision_made":"no","referee_comment":"[Abstract (validation description)] The manuscript provides no formal argument, inductive proof, or counter-example analysis establishing that the decomposition rules yield bit-for-bit identical results for arbitrary affine recurrences (beyond cases where the local recurrence already matches the target associative form). This is load-bearing for the claim that ScanWeaver handles a 'broader class of affine recurrences.'"}],"tokens_in":1328,"tokens_out":430,"duration_ms":16564,"standing_objections":["No formal inductive proof or counter-example analysis is provided for semantics preservation on arbitrary affine recurrences beyond the matched cases."]},"desk_editor":{"model":"grok-4.3","letter":"The main takeaway is that ScanWeaver turns affine recurrences into a compiler abstraction with an end-to-end MLIR-to-GPU path using Blelloch scans. This is a step past single-model kernel work and toward something reusable for workloads like selective scans in Mamba-style models.\n\nWhat the paper does is elevate the recurrence structure itself rather than optimizing one family at a time. The lowering pipeline covers decomposition, associative scan representation, MLIR GPU codegen, and actual execution. They validate the full chain on forward selective-scan cases where the local semantics already line up, and they compare against PyTorch, CUDA, and the production Mamba kernel. That concrete pipeline is the useful part.\n\nThe soft spot is the correctness argument. The abstract ties success to cases with matched local recurrence semantics, but it does not show why the decomposition preserves exact results for arbitrary affine recurrences or provide an inductive argument, counterexample search, or even basic equivalence checks beyond the motivating form. Without that, it is unclear how far the claim extends. The lack of any benchmark numbers or error analysis in the abstract also makes the performance side hard to assess yet.\n\nThis is for compiler and systems people who work on MLIR, parallel scans, or state-space model implementations. A reader who wants to see how recurrence structure can be made first-class would find the lowering details worth looking at.\n\nIt should go to peer review. The idea is distinct from prior work and the implementation path is specific enough that referees can check the details and ask for the missing equivalence evidence.","headline":"ScanWeaver gives a reusable MLIR lowering path for affine recurrences to Blelloch scans, but the abstract leaves the general semantics claim under-supported.","tokens_in":2331,"tokens_out":393,"would_cite":false,"duration_ms":12473,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"grok-4.3","headline":"ScanWeaver converts affine recurrences into associative scans that lower end-to-end through MLIR to parallel Blelloch execution on GPUs.","keywords":["affine recurrences","associative scan","Blelloch scan","MLIR","GPU parallelization","selective state-space models","Mamba","compiler lowering"],"falsifier":"Execute the generated GPU program on the same input sequences used by a sequential reference implementation and check whether every output element matches to machine precision; a single mismatch on any element falsifies semantic preservation.","tokens_in":2603,"feed_emoji":"⚡","tokens_out":643,"duration_ms":14697,"temperature":0.7,"pith_summary":"The paper introduces ScanWeaver as a compiler framework that takes recurrence computations, such as the input-dependent scans in selective state-space models, and rewrites them as associative scan operations. This rewrite allows systematic lowering via MLIR to compiler-generated Blelloch scans that execute in parallel on GPUs. The work treats the recurrence structure itself as a reusable compiler abstraction rather than a model-specific optimization target. Validation covers decomposition, lowering, code generation, and actual hardware execution, with results compared against sequential PyTorch, CUDA, and fused Mamba baselines. The central goal is to remove the sequential bottleneck while keeping the original linear-time semantics intact across a class of affine recurrences.","feed_headline":"Compiler converts selective scans to parallel GPU code","feed_subtitle":"ScanWeaver rewrites affine recurrences as Blelloch scans and lowers them through MLIR for accelerator execution.","key_machinery":"Associative scan lowering that rewrites input-dependent affine recurrences into Blelloch-compatible parallel scans inside the MLIR infrastructure.","core_discovery":"ScanWeaver decomposes affine recurrences that arise in modern ML workloads into associative forms, then applies MLIR-based lowering to produce executable GPU programs that implement the Blelloch scan algorithm, preserving exact forward semantics for selective-scan workloads.","pith_inferences":["The same decomposition technique could apply to recurrence patterns outside ML, such as certain dynamic programming or time-series algorithms.","Integration into standard ML frameworks might allow automatic parallelization of new recurrence-based layers without manual kernel development.","The approach opens a path to testing whether other scan variants or higher-order recurrences can be lowered through the same MLIR pipeline."],"forward_implications":["Forward selective-scan workloads from models like Mamba can execute in parallel on GPUs using only compiler-generated code.","The same lowering path applies to other affine recurrences that share the same local recurrence structure.","MLIR becomes the single source for both the recurrence description and the final GPU binary.","Hand-written CUDA scan kernels can be replaced by verified compiler output for this class of computations."],"fun_headline_variants":["ScanWeaver lowers affine recurrences to Blelloch scans on GPU","MLIR lowers selective scans to Blelloch GPU execution","ScanWeaver parallelizes affine recurrences with MLIR Blelloch scans","ScanWeaver decomposes affine recurrences for Blelloch GPU execution"],"cache_read_input_tokens":64,"weakest_assumption_plain":"The target affine recurrences keep their exact original semantics after decomposition into associative Blelloch scans, without any approximations or extra runtime checks that would change the computation.","fun_headline_variants_meta":{"raw":{"variants":["ScanWeaver lowers affine recurrences to Blelloch scans on GPU","MLIR lowers selective scans to Blelloch GPU execution","ScanWeaver parallelizes affine recurrences with MLIR Blelloch scans","ScanWeaver decomposes affine recurrences for Blelloch GPU execution"]},"model":"grok-4.3","cost_usd":0.008012,"raw_usage":{"total_tokens":3543,"prompt_tokens":623,"num_sources_used":0,"completion_tokens":75,"cost_in_usd_ticks":80115500,"prompt_tokens_details":{"text_tokens":623,"audio_tokens":0,"image_tokens":0,"cached_tokens":64},"completion_tokens_details":{"audio_tokens":0,"reasoning_tokens":2845,"accepted_prediction_tokens":0,"rejected_prediction_tokens":0}},"tokens_in":623,"tokens_out":75,"duration_ms":20929,"temperature":1.0,"reasoning_tokens":2845,"cache_read_input_tokens":64,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-06-28T18:04:44.274381+00:00","model_set":{"reader":"grok-4.3"},"falsifier":"Execute the generated GPU program on the same input sequences used by a sequential reference implementation and check whether every output element matches to machine precision; a single mismatch on any element falsifies semantic preservation.","supporting_citations":[],"review_version":1}