{"id":"97815860-e779-4845-9fe7-1f0f5d87d09c","arxiv_id":"2607.20130","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":4,"one_line_summary":"A reinforcement-learning decoder for quantum LDPC codes that selects clusters of variable nodes instead of single nodes preserves most of the error-rate benefit while cutting serial scheduling decisions by about an order of magnitude.","lead":"This paper teaches a quantum error-correction decoder to update groups of qubits instead of one at a time, cutting the number of scheduling steps roughly tenfold while keeping most of the error-correction gain. The result matters because quantum LDPC decoders need low latency on real hardware, and this gives a direct way to trade parallelism against serial control.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Latency savings claim depends on unproven conflict-free parallel cluster updates; random partitions admit memory conflicts, so n/B serial-depth reduction may not yield real speedups.","rationale":"The reader identified the same weakest assumption, and I agree it is the load-bearing issue. The paper's contribution is framed not merely as error-rate parity but as a latency–parallelism tradeoff; the abstract and intro explicitly promise a roughly order-of-magnitude serial-latency reduction. The cluster-state quantization, MDP formulation, and Lemma 1 are internally consistent, and the numerical BLER results are plausible, though they lack error bars and code. However, no hardware implementation, conflict-free partition, or measured latency is provided. The paper honestly flags the ideal-parallel-update assumption, but disclosure does not satisfy the burden of evidence for the central claim. A timing model is cheap and would settle whether the n-to-n/B reduction translates to real speedups. There is no reason to reject outright; the algorithm itself may work. The appropriate verdict remains CONDITIONAL: acceptance should require validating the latency claim under a concrete partition and memory model. The missing hyperparameters and confidence intervals are secondary reproducibility issues, not the core correctness risk.","tokens_in":15810,"tokens_out":4767,"duration_ms":49204,"concrete_test":"Build a timing model for the [[288,12,18]] BB code with one read/write port per check node. Take the exact random partition used in Fig. 5 (B=10), compute per-cluster update latency as the maximum number of conflicting VN-to-CN accesses to any check plus per-conflict serialization cost; total per-iteration latency is the sum over the 29 cluster selections. Compare with (a) VN-level RL-S and (b) the ideal 29/288 latency ratio. Repeat using a conflict-free partition found by check-node coloring. If the realized speedup over RL-S drops below ~2–3x while the ideal model predicts ~10x, the latency claim fails; if it stays ~10x, this objection is refuted.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The paper's headline advantage—cluster-level scheduling cuts serial depth per BP iteration from n to ceil(n/B), e.g., 29 vs 288 for the [[288,12,18]] BB code at B=10—is only meaningful if each cluster update has constant latency. The paper itself states in Sec. III that its random VN partitions 'are not designed to guarantee conflict-free hardware implementations' and that 'the latency analysis assumes ideal parallel cluster updates.' Sec. IV's O(Imax*Ncl) scaling relies on this ideal model. In a QLDPC Tanner graph, VNs in a random cluster often share check nodes. Under single-port check-node memories—a standard low-complexity BP hardware assumption—concurrent VN-to-CN message updates to a common check collide, forcing serialization or multi-port memory. Simultaneous hard-decision flips and syndrome updates can likewise create read/write conflicts. Thus per-cluster latency is not constant; it can grow with B and with check-sharing density. The abstract's 'roughly an order of magnitude' latency reduction is therefore not established for any physical decoder. This is the load-bearing assumption behind the central claim.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper extends RL-based sequential belief-propagation (RL-S) decoding of QLDPC codes from variable-node-level scheduling to cluster-level scheduling. The VNs are partitioned into fixed clusters; at each scheduling step an RL agent selects one cluster, and all VNs in that cluster are updated in parallel from pre-update messages. To keep tabular Q-learning tractable, the cluster state is a quantized, permutation-invariant normalized histogram of local mismatch weights. The paper formulates the cluster-level MDP, reward, and Q-learning update, and provides numerical results on the [[882,24,18≤d≤24]] code B1 over the independent Pauli-X channel and on the [[288,12,18]] BB code over the depolarizing channel. The central claim is that cluster-level scheduling preserves most of the error-rate benefit of VN-level RL-S while reducing the number of scheduling decisions per BP iteration from n to ceil(n/B), e.g., from 288 to 29 for the [[288,12,18]] code at B=10, yielding an order-of-magnitude reduction in serial scheduling latency under an ideal parallel cluster-update model.","tokens_in":16109,"tokens_out":4982,"duration_ms":55155,"significance":"If the latency claim can be substantiated, the proposed clustered RL-S decoder would be a meaningful step toward making learned sequential BP scheduling practical for latency-sensitive QLDPC decoding: it retains the state-dependent asymmetry that helps BP while enabling intra-cluster parallelism. The paper's quantized histogram state representation is a clean and useful idea for compressing cluster-level state, and Lemma 1 correctly characterizes the residual-mismatch update under simultaneous flips. The numerical comparison against QBP, QBPGD, and the VN-level RL-S baseline is honest and suggests the error-rate degradation from clustering is modest for moderate B. However, the headline latency advantage rests on an ideal parallel cluster-update model that the paper itself acknowledges is not realized by its random VN partitions; this is a load-bearing gap. The experimental section also omits training details and error bars, making the quantitative claims difficult to verify.","major_comments":[{"comment":"The central latency claim—serial scheduling depth reduced from O(n) to O(ceil(n/B))—depends entirely on the assumption that all VNs in a selected cluster can be updated in parallel with constant per-cluster latency. The paper states in Section III that the random VN partitions 'are not designed to guarantee conflict-free hardware implementations' and that 'the latency analysis assumes ideal parallel cluster updates.' In a random VN cluster, VNs frequently share check nodes. Under a standard single-port check-node memory or message-passing model, concurrent VN-to-CN updates to a shared check collide and must be serialized; simultaneous hard-decision flips and syndrome updates can similarly introduce read/write conflicts. Thus the per-cluster update time is not necessarily constant, and the O(Imax*Ncl) scaling in Section IV does not imply a comparable wall-clock latency reduction. The abst","section":"Sections III and IV"},{"comment":"The numerical results are not fully reproducible and do not support error bars or statistical significance. The paper does not report the number of training episodes E_max, the learning rate α, the initial and minimum exploration probabilities ε0/ε_min, the number of random VN partitions used, or the number of Monte Carlo trials per error probability. Figures 2–5 show single BLER/FER curves without confidence intervals. Since the central claim is that clustered RL-S 'preserves most' of the error-rate benefit of VN-level RL-S, the reader cannot tell whether the observed small gaps are robust or are artifacts of a particular partition and training run. Please provide the missing hyperparameters, repeat the experiments over multiple random partitions and channel realizations, and report confidence intervals or error bars. Without this, the qualitative conclusion is plausible but not quantit","section":"Section V"}],"minor_comments":[{"comment":"The expression C(L+A_max, A_max) counts all compositions of L into A_max+1 parts, which is an upper bound on the number of reachable quantized cluster states for a fixed cluster size B. Not every composition can arise from a normalized histogram of B integer mismatch weights. The statement that the number of possible states 'depends on the quantization resolution rather than the cluster size' should be qualified as an upper-bound statement; for a concrete B, the reachable set depends on B through the constraint Σ c_r = B.","section":"Section III-C, Eq. (9)"},{"comment":"In the comparison of quantization resolutions, B and L are varied simultaneously (B=10,L=8; B=20,L=16; etc.). This couples the two effects and does not isolate the influence of L. For a clean ablation, fix B and sweep L (or vice versa).","section":"Section V, Fig. 4"},{"comment":"There is a typo in the first sentence: 'For the the current mismatch weight w = ∥δ∥1' should read 'For the current mismatch weight w = ∥δ∥1.'","section":"Section III-E"},{"comment":"The text says a block is erroneous if the correction is 'logically nontrivial,' but the procedure for identifying logical nontriviality (e.g., basis of logical operators, parity checks) is not described. Please include this detail or cite the standard method used in the baseline implementations.","section":"Section V"}],"recommendation":"major_revision","confidential_remarks":"The core algorithmic idea is sound and the state-compression technique is worth publishing, but the advertised latency advantage is not supported without a conflict-free partition or a hardware-aware latency model. The missing experimental details also need to be supplied. I recommend major revision rather than rejection because the issue is fixable by either adding a suitable partition construction/analysis or carefully downgrading the latency claims, and by completing the experimental reporting."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Short version: this is a coherent, honest extension of the RL-S line. The new piece is real: instead of picking one VN per scheduling step, the agent picks a fixed cluster and updates all VNs in that cluster in parallel from pre-update messages. The permutation-invariant quantized histogram state is a sensible compression, Eq. (9) and Lemma 1 check out, and the numerical curves show that for the codes tested, cluster-level scheduling preserves most of the RL-S error-rate gain while cutting scheduling decisions per iteration from n to ceil(n/B). That is a genuinely useful design point.\n\nWhat the paper does well: it is transparent about its own limits. Section III says the random partitions are not conflict-free and the latency analysis assumes ideal parallel cluster updates. The complexity comparison in Section IV is clearly labeled as an ideal-parallel model. The RL formulation — cluster MDP, reward normalized by degree sum, Q-learning update — is straightforward and reproducible in principle. Benchmarks against QBP and QBPGD are there.\n\nWhere it is soft: the headline \"order-of-magnitude latency reduction\" is not actually established for any physical decoder. In a random cluster, VNs share check nodes, and simultaneous VN-to-check updates to a shared check collide under single-port check-node memory; per-cluster latency can grow with B. The paper acknowledges exactly this, but the acknowledgment sits in Section III while the abstract and Section IV lean on the ideal model. Until there is a conflict-free partition construction or a concrete memory model, the latency claim should be read as a reduction in scheduling decisions, not a proven speedup. Also absent: code, error bars, and key RL hyperparameters (learning rate, discount, episode count). For an RL paper, that is below the current reproducibility bar. The numerical results are plausible but not independently checkable as reported.\n\nThe math itself is sound. Nothing circular, no fitted constants relabeled as predictions. The citation pattern leans on the authors' own sequence of papers, but that is the natural lineage here and the baselines are concrete.\n\nBottom line: worth a serious referee. I would send it to review with a request for code and full hyperparameters, and with a revision that either constructs conflict-free VN clusters or dials the latency language down to match the model actually analyzed. A reader working on learned or hardware-aware QLDPC decoders will get value from this.","headline":"A coherent, honest extension of learned sequential QLDPC decoding that trades a real latency claim for an ideal-model assumption; worth refereeing with requests for code and conflict-free partitions.","tokens_in":16566,"tokens_out":1974,"would_cite":true,"duration_ms":24562,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["81P70","94B35"],"pacs":["03.67.Pp"],"model":"deepseek-v4-flash","headline":"Cluster-based learned scheduling cuts QLDPC belief-propagation decisions from one per qubit to one per cluster while keeping most of the error-rate gain.","keywords":["quantum LDPC codes","belief propagation decoding","reinforcement learning scheduling","cluster-based sequential decoding","permutation-invariant state","quantized histogram","quantum error correction","CSS codes"],"falsifier":"Build a cycle-accurate model or FPGA implementation of clustered RL-S with the paper's random partitions on the [[288,12,18]] BB code and measure wall-clock time for B=10 against VN-level RL-S. If 29 cluster decisions per iteration are not faster than 288 VN decisions—because updates contend for the same check-node memories—the central latency claim is falsified. A simpler check is to compare random partitions with an oracle conflict-free partition; if no conflict-free partition exists for a given code, the n-to-ceil(n/B) depth reduction is only theoretical.","tokens_in":15665,"feed_emoji":"⚛️","tokens_out":5787,"duration_ms":60029,"temperature":0.7,"pith_summary":"Quantum low-density parity-check (QLDPC) codes need decoders that both suppress errors and run fast, but belief propagation is weak on their short-cycle, degenerate graphs. A learned, sequential schedule (RL-S) fixes much of the error-rate problem by letting a reinforcement-learning agent pick one variable node at a time, yet that serializes the decoder: up to n scheduling decisions per iteration. This paper claims the serial depth can be broken by partitioning the variable nodes into fixed clusters and letting the agent choose one cluster per step; all nodes in the chosen cluster then update in parallel from the same pre-update messages. The authors introduce a permutation-invariant cluster state—a quantized normalized histogram of local mismatch weights—whose size depends on quantization resolution, not cluster size, so tabular learning stays practical. On representative codes, clustered scheduling preserves most of RL-S's error-rate improvement while reducing scheduling decisions per iteration from n to ceil(n/B), e.g. from 288 to 29 for a [[288,12,18]] code, giving a roughly tenfold latency reduction under an ideal parallel-update model.","feed_headline":"Clustered scheduling cuts QLDPC decode latency ~10x","feed_subtitle":"Grouping qubits into clusters preserves learned sequential BP error-rate gains while cutting scheduling steps from 288 to 29.","key_machinery":"A cluster-level Markov decision process whose state is a permutation-invariant quantized histogram of local mismatch weights. For each variable node, the local mismatch weight is the number of currently unsatisfied checks adjacent to it; a cluster's histogram counts how many of its nodes have each weight. Normalizing by cluster size and quantizing to L bins with a largest-remainder rule yields a state whose count is C(L+A_max, A_max), independent of B. The Q-learning update uses a one-step reward of normalized mismatch reduction plus a terminal bonus, and the action is the index of the next cluster; Lemma 1 gives the odd-parity rule for how a parallel set of flips changes the residual syndro","core_discovery":"The central claim is that the benefit of learned sequential scheduling for QLDPC decoding comes mainly from the coarse, syndrome-driven order in which groups of bits are refreshed, not from the fine grain of one-bit updates. The paper argues this by replacing the VN-level action space with a cluster-level action space: at each scheduling step the agent selects a cluster, all variable nodes in it update simultaneously from identical pre-update messages, and hard-decision flips are applied at once. To keep that decision process tractable, each cluster is summarized by a normalized histogram of local mismatch weights, quantized onto an integer simplex; the resulting state space has C(L+A_max, A","pith_inferences":["The order-of-magnitude latency claim is conditional on conflict-free parallel cluster updates; the paper uses random, non-conflict-free partitions, so graph-aware partition design is the natural next step and may be required for real hardware to see the savings.","The histogram state discards within-cluster identity and correlations, so very large clusters may lose the scheduling adaptivity that produces the error-rate gain; adaptive or hierarchical cluster granularity is a testable remedy.","The same compressed state idea—summarizing a group by a quantized distribution of local mismatch weights—could transfer to other sequential message-passing decoders beyond quantum codes, wherever a residual syndrome guides the update order.","Combining cluster-level scheduling with list-based or bit-flipping continuation branches could push the latency–performance tradeoff further than either extension alone."],"forward_implications":["If the central claim holds, learned sequential BP scheduling for QLDPC codes no longer needs a serial decision chain of length n: one BP iteration uses only ceil(n/B) scheduling decisions.","For the [[288,12,18]] BB code with B=10, this drops 288 VN-level decisions to 29 cluster-level decisions, an order-of-magnitude reduction in serial scheduling latency under the paper's ideal parallel cluster-update model.","The quantized histogram state keeps the Q-table size controlled by the quantization resolution L and the number of clusters, rather than by cluster size, so larger clusters do not blow up the learning state space.","The same cluster state and update rule carry over to the depolarizing channel by using two residual vectors (δX, δZ) and quaternary BP, so the latency improvement is not limited to bit-flip noise.","Moderate cluster sizes preserve most of the error-rate gain of VN-level RL-S, especially when the iteration budget is at least a few hundred."],"fun_headline_variants":["Cluster BP: 10x faster QLDPC decoding","Cluster-wise BP: near-sequential gains, 10x speedup","Learn cluster order: QLDPC BP speeds up"],"cache_read_input_tokens":2304,"weakest_assumption_plain":"The load-bearing premise is the ideal parallel cluster-update model—all variable nodes in a selected cluster update simultaneously from the same pre-update messages with no memory or communication conflicts; the paper's own random partitions are not conflict-free, so absent such hardware, the serial-depth reduction may not become real latency reduction.","fun_headline_variants_meta":{"raw":{"variants":["Cluster BP: 10x faster QLDPC decoding","Cluster-wise BP: near-sequential gains, 10x speedup","Learn cluster order: QLDPC BP speeds up"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000492,"raw_usage":{"total_tokens":2279,"prompt_tokens":795,"completion_tokens":1484,"prompt_tokens_details":{"cached_tokens":256},"prompt_cache_hit_tokens":256,"prompt_cache_miss_tokens":539,"completion_tokens_details":{"reasoning_tokens":1427}},"tokens_in":539,"tokens_out":1484,"duration_ms":11972,"temperature":1.0,"reasoning_tokens":1427,"cache_read_input_tokens":256,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-01T10:40:18.683846+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Build a cycle-accurate model or FPGA implementation of clustered RL-S with the paper's random partitions on the [[288,12,18]] BB code and measure wall-clock time for B=10 against VN-level RL-S. If 29 cluster decisions per iteration are not faster than 288 VN decisions—because updates contend for the same check-node memories—the central latency claim is falsified. A simpler check is to compare random partitions with an oracle conflict-free partition; if no conflict-free partition exists for a given code, the n-to-ceil(n/B) depth reduction is only theoretical.","supporting_citations":[],"review_version":1}