{"id":"e3d32a91-4552-4f84-bb66-6b493aa6bd6d","arxiv_id":"2505.09361","paper_version":1,"verdict":"REJECT","confidence":"HIGH","novelty_score":5.0,"correctness_risk":"high","formal_verification":"none","parameter_count":3,"one_line_summary":"MixQ-GNN picks per-component bit-widths for quantized GNNs and claims exact integer message passing via a new theorem, but the theorem is flawed as written.","lead":"This paper proposes MixQ-GNN, a framework that uses differentiable search to pick mixed-precision bit-widths for every component of a graph neural network, and claims a theorem that integer message passing can match full-precision results. Generalist readers might care because efficient GNN inference matters for large graph applications, but the theorem's proof contains an algebraic error that undermines the guarantee.","discovery_kind":"new_application","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Theorem 1's zero-point cross term is algebraically wrong: the proof's fourth term should be 1_n[(Z_a⊙S_a)^T 1_n](Z_x⊙S_x)^T, not (Z_a⊙S_a)(Z_x⊙S_x)^T, so the stated exact FP32 equality does not follow.","rationale":"The reader's formal weakest_assumption concerns the BitOPs-to-latency proxy, but the reader's rationale independently identifies the zero-point cross-term error in Theorem 1. My stress test confirms that this algebraic error is the most load-bearing problem: the abstract and Section 4 claim an exact numerical-equality guarantee, and that guarantee is what justifies the reported 5.5x/5.1x bit-operation reductions. Since the proof's fourth term is dimensionally inconsistent with the stated vector convention, the theorem statement as written is false. A corrected C3 would restore the argument, so the paper is rejectable as written but potentially salvageable, matching the reader's verdict. I set agreement_with_reader to 'partial' because the reader's designated weakest assumption is not the same as my identified concern, although the reader's rationale does flag the theorem error.","tokens_in":23833,"tokens_out":10299,"duration_ms":91080,"concrete_test":"Symbolically re-derive the fourth term of the expansion in Section 4: [1_n(Z_a⊙S_a)^T][1_n(Z_x⊙S_x)^T], then evaluate both the stated and corrected C3 on a random graph with n=3, f=2, S_a=S_x=S_y=1, Z_a=Z_x=1 (all ones). The stated RHS for Qf_a(A)Qf_x(X) differs from the correct expansion by (n−1)·J_{3×2}. Then run MixQ/test/test_graph_conv_module.py on this input; if the test passes, the code must be implementing a different C3 from the one printed in Theorem 1.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The proof of Theorem 1 in Section 4 expands Qf_a(A)Qf_x(X) into four terms. The fourth term is written as +(Z_a⊙S_a)(Z_x⊙S_x)^T, but the product of the two subtracted zero-point terms is [1_n(Z_a⊙S_a)^T][1_n(Z_x⊙S_x)^T] = 1_n[(Z_a⊙S_a)^T 1_n](Z_x⊙S_x)^T = (Σ_k Z_{a,k}S_{a,k})·1_n(Z_x⊙S_x)^T, which is not the outer product (Z_a⊙S_a)(Z_x⊙S_x)^T. In the standard per-tensor scalar case, Z_a⊙S_a is a constant vector and the missing factor is exactly n. Consequently the displayed C3 in Theorem 1 is incorrect, and the claimed equality Qy(AX) = C1⊙Qa(A)Qx(X)⊙C2 + C3 does not follow from the derivation. Because the central contribution is precisely this numerical-equality guarantee, the integer-only message passing schema lacks its stated correctness basis. The repository tests mentioned in the paper cannot confirm the theorem as written unless the implementation uses a corrected C3.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes MixQ-GNN, a mixed-precision quantization framework for GNN inference. Its main theoretical contribution is Theorem 1, which claims that the quantized message-passing product Qy(AX) can be computed from integer matrix products Qa(A)Qx(X) plus precomputed correction terms C1, C2, C3, with numerical equality to the FP32 quantized aggregation. The framework then uses a DARTS-style continuous relaxation to select bit-widths for each GNN component, and reports 5.5x and 5.1x average BitOPs reductions on node and graph classification benchmarks, with code and unit tests provided.","tokens_in":24044,"tokens_out":13980,"duration_ms":123711,"significance":"If the theorem can be corrected, the paper's idea of exact integer-only message passing with per-component mixed precision is a useful contribution for GNN deployment. The inclusion of DQ integration, large-scale experiments, and public code/tests are strengths. However, the correctness of the theorem and the reproducibility of the headline efficiency numbers are currently the main obstacles.","major_comments":[{"comment":"The expansion of Qf_a(A)Qf_x(X) in the proof of Theorem 1 is algebraically incorrect. With per-row S_a, Z_a and per-column S_x, Z_x, the fourth term of the expansion is n(Z_a⊙S_a)(Z_x⊙S_x)^T, not (Z_a⊙S_a)(Z_x⊙S_x)^T; the factor n comes from 1_n^T 1_n. Equivalently, the product of the two broadcast zero-point matrices is 1_n[(Z_a⊙S_a)^T 1_n](Z_x⊙S_x)^T. As printed, C3 omits this factor, so the claimed equality Qy(AX)=C1⊙Qa(A)Qx(X)⊙C2+C3 does not follow from the derivation. Because this theorem is the basis for the integer-only message-passing scheme, the central correctness claim is currently unsupported. Correcting C3, and stating the broadcasting convention for the zero-point vectors explicitly, would fix the proof; the repository tests cannot validate the theorem as stated unless the implementation already uses the corrected offset.","section":"Section 4, proof of Theorem 1"},{"comment":"The headline efficiency claims are not reproducible from the reported tables. Section 5.3 states an average 5.5x reduction in bit operations across Cora, CiteSeer, PubMed, and OGB-Arxiv, but Table 3 does not support this: for λ=-ε the per-dataset GBitOPs reductions are 16.11/3.95=4.08, 50.68/12.44=4.07, 41.7/10.34=4.03, and 692.87/167.50=4.14, averaging 4.08; for λ=0.1 the average is about 6.2, and for λ=1 about 8.6. Similarly, the 5.1x claim in Section 5.4 is not supported by Table 8: with λ* the per-dataset ratios average 4.15, and with λ=1 they average 4.76. The authors should recompute the averages, specify exactly which configuration is used, or qualify the claims accordingly.","section":"Section 5.3 and Section 5.4"},{"comment":"The BitOPs metric is validated only on a single message-passing layer, and the Pearson correlations are 0.59 on the AMD EPYC 9534, 0.70 on Intel Xeon, and 0.95 on Apple M1. The text's conclusion that 'inference times increase proportionally as BitOPs increase' is too strong, especially for the AMD platform that matches the CPU in the main experiments. Since all reported speedups are in BitOPs rather than wall-clock time, the paper should either provide end-to-end timing for full GNN inference on the target hardware or substantially temper the efficiency claims.","section":"Section 5.1, Figure 8"}],"minor_comments":[{"comment":"The caption says 'Bit-width options: {2, 4, 8}, totaling 39 possible combinations,' but 3^9 = 19683; the text later correctly says 19,683 combinations, so the caption should be corrected.","section":"Figure 2 caption"},{"comment":"The displayed MPNN definitions have missing mathematical symbols due to formatting; they should be typeset cleanly so the message/aggregate/update structure is unambiguous.","section":"Equations (1) and (2)"},{"comment":"The proof of Theorem 1 uses ⊙ with vectors and matrices without specifying the broadcasting convention; the dimensions and broadcasting of S_a, Z_a, S_x, and Z_x should be defined explicitly before the expansion.","section":"Section 4, notation"},{"comment":"The PubMed block lists 'DQ [16]' in the DQ row, which appears to be a citation inconsistency; the table and the surrounding text should use consistent labels for the compared methods.","section":"Table 3"},{"comment":"The x-axis appears to mix memory units (MB) and operation counts; the axis label and tick units should be clarified.","section":"Figure 1"}],"recommendation":"major_revision","confidential_remarks":"The algebraic error in Theorem 1 is fixable, and the framework may be sound after correction, so I recommend major revision rather than rejection. However, the efficiency claims must be recomputed from the tables; if the corrected numbers no longer support the 5.5x and 5.1x reductions, the authors should report the correct values."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Colleague, the first thing you should know: the paper's central theorem, which is supposed to guarantee integer message passing exactly reproduces FP32 aggregation, has an algebraic error. The fourth term in the expansion of Q^f_a(A)Q^f_x(X) is not (Za⊙Sa)(Zx⊙Sx)^T. The two subtracted zero-point terms are each multiplied by an all-ones vector, so the product is 1_n[(Za⊙Sa)^T 1_n](Zx⊙Sx)^T, which reduces to n times the outer product in the standard per-tensor scalar case. As written, C3 is wrong and the claimed exact equality does not follow. The stress-test note lands; I checked the derivation against the text. The repository tests cannot confirm the theorem as stated unless the implementation uses a corrected C3.\n\nWhat is new and decent: applying DARTS-style continuous relaxation to component-wise bit-width selection in GNNs is a legitimate new application, and the paper deserves credit for that. The experiments are broad—node classification, graph classification, large-scale datasets, and a synthetic case—and the ablation against random bit-width choices is the right kind of sanity check. The framework is cleanly described, the integration with DQ is sensible, and code and tests are provided. The theorem, once corrected, is a useful way to express fused integer message passing.\n\nSoft spots, in proportion. The theorem error is load-bearing because the whole efficiency claim rests on integer-only aggregation being numerically equivalent to FP32. It is fixable, but not a typo you can ignore. Second, the headline reductions of 5.5x and 5.1x are not reproducible from the tables without an unspecified averaging rule, and Table 3 has an internal inconsistency: OGB-Arxiv shows the same GBitOPs (167.50) for different reported average bit-widths. Third, the BitOPs-to-runtime validation is only a single message-passing layer, and the AMD correlation is a moderate 0.59, so end-to-end speedups for full architectures remain unproven.\n\nWho is this for: researchers and practitioners working on quantized GNN inference, especially edge deployment. The search recipe and the corrected message-passing formula would both be useful. I would not cite the theorem as written, and I would not use the averages until they are recomputed transparently. But this is not a paper to wave away: it is a real attempt at a hard problem, with code and experiments, and the main flaw is identifiable and correctable.\n\nRecommendation: send it to serious peer review, not desk reject. Require the corrected proof, a reproducible averaging rule, a fix for the table inconsistency, and ideally end-to-end timing on at least one full architecture. With those, the paper could plausibly be accepted after revision.","headline":"The central theorem, which guarantees integer message passing exactly matches FP32, is algebraically wrong as stated—the C3 zero-point cross term drops a factor of n—though the mixed-precision search framework is a legitimate new application and is worth serious referee attention once the proof and reported averages are fixed.","tokens_in":24627,"tokens_out":2749,"would_cite":false,"duration_ms":30701,"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 paper claims that integer-only message passing can reproduce full-precision FP32 aggregation exactly, and that searching per-component bit-widths with relaxed parameters yields 5.5x and 5.1x reductions in bit operations for node and…","keywords":["graph neural networks","mixed precision quantization","integer-only inference","message passing","bit-width search","quantization-aware training","bit operations","continuous relaxation"],"falsifier":"Measure wall-clock inference time for a full quantized GCN on Cora and GraphSAGE on Reddit at the exact bit-widths MixQ-GNN selects, on the same AMD EPYC and Apple M1 hardware used in Figure 8; if the end-to-end speedup is far below the reported 5.5x BitOPs reduction, the efficiency claim collapses. A separate check: numerically compare $Q_y(AX)$ from the theorem's integer path against $Q_a^f(A)Q_x^f(X)$ for random $A$ and $X$; any disagreement beyond integer rounding would falsify the equality claim.","tokens_in":23584,"feed_emoji":"🧮","tokens_out":9827,"duration_ms":89507,"temperature":0.7,"pith_summary":"The paper tries to show that quantized graph neural networks can do their most expensive step—aggregating messages from neighbors—entirely in integer arithmetic, with no loss in numerical fidelity relative to full-precision aggregation. Its Theorem 1 gives an identity that rewrites the quantized product $Q_y(AX)$ as the integer product $Q_a(A)Q_x(X)$ plus cheap scale and zero-point corrections, so sparse-dense matrix multiplication over the graph no longer needs floating point. On top of this, MixQ-GNN uses a differentiable search over bit-width choices for every component of a GNN layer, returning a per-component precision assignment without exhaustive enumeration. If the framework holds up, the reported 5.5x and 5.1x reductions in bit operations for node and graph classification would make GNN inference substantially cheaper on integer-friendly hardware.","feed_headline":"Integer-only message passing cuts GNN bit ops 5.5x","feed_subtitle":"A quantized-aggregation theorem matches FP32 results exactly while a learned search picks each component's bit-width.","key_machinery":"The load-bearing object is Theorem 1, the Quantized Message Passing Schema identity $Q_y(AX) = C_1 \\odot Q_a(A)Q_x(X) \\odot C_2 + C_3$. It converts the aggregation step $AX$—normally a sparse-dense FP32 matrix multiplication—into an integer matrix product of the quantized adjacency and feature matrices, with the scale vectors $C_1$, $C_2$ and the zero-point correction $C_3$ applied as cheap post- and pre-processing. The second piece of machinery is the relaxed bit-width search: each quantizer is replicated for every allowed bit-width and mixed by softmax weights $\\alpha$, so gradients can flow into the choice itself, and a differentiable penalty $C(T) = \\sum_i b_i p_i |T|$ pushes the search toward low bit-widths. Together these separate the what-precision question, solved by relaxation, from the how-to-compute-exactly question, solved by the theorem.","core_discovery":"On the paper's own terms, the central discovery is that message passing in GNNs can be fused through quantization: the output of aggregation, $Y = AX$, can be computed directly from the quantized integer matrices $Q_a(A)$ and $Q_x(X)$ as $Q_y(AX) = C_1 \\odot Q_a(A)Q_x(X) \\odot C_2 + C_3$, where $C_1 = S_a$, $C_2 = S_x \\oslash S_y$, and $C_3$ collects zero-point offset terms. The corrections involve only elementwise operations and rank-one terms, so the integer sparse-dense multiplication remains the dominant cost. The theorem is verified in the code on GCN and GIN layers, and it is the basis for the claim that integer-only aggregation produces exactly the aggregated result that the fake-quantized FP32 pipeline would compute. The surrounding MixQ-GNN framework then performs quantization-aware training with a softmax relaxation over bit-width choices such as $\\{2,4,8\\}$ or $\\{4,8\\}$, with a memory-style penalty controlled by $\\lambda$, and selects the highest-probability bit-width per component after training.","pith_inferences":["Inference: The theorem separates aggregation precision from message precision, so one could quantize edge and feature messages more aggressively while keeping aggregation exact; the paper does not test this decoupling.","Inference: If BitOPs track energy consumption as well as time on integer-friendly hardware, the same 5x reductions could translate into comparable energy savings, a claim the paper does not make and does not measure.","Inference: Because the correction terms $C_3$ are rank-one and cheap, the theorem may extend to other bilinear aggregation operators, but not directly to mean or max pooling; the paper's choice of max pooling in graph-level tasks suggests overflow was the practical concern.","Inference: The relaxed one-shot search could be reused as a warm start for post-training quantization, amortizing the search cost across many deployments of the same architecture; the paper only trains from scratch."],"forward_implications":["Aggregation in any sum-based message passing network can run as integer sparse-dense matrix multiplication with no numerical penalty relative to fake-quantized FP32, opening GNN layers to integer hardware accelerators.","The per-component bit-width search is differentiable, so precision assignments over inputs, adjacency matrices, parameters, and intermediate activations can be learned simultaneously instead of chosen by exhaustive search.","On node classification, the framework reports an average 5.5x reduction in bit operations versus FP32 across Cora, CiteSeer, PubMed, and OGB-Arxiv; on graph classification, it reports 5.1x across five TUDatasets.","Existing graph-structure-aware quantizers can be inserted into the framework: combining with the DQ quantizer raises Cora accuracy to 81.8 percent while keeping bit operations near the low end.","Large-scale GraphSAGE experiments show the search transfers to graphs with millions of edges, with an average 5.6x bit-operation reduction over the FP32 baseline."],"supporting_citations":[{"why":"Defines Degree-Quant, the graph-structure-aware quantizer MixQ-GNN integrates and its main baseline, and supplies the claim that high in-degree nodes dominate quantization error.","marker":"[8]"},{"why":"Introduces A2Q, the per-node mixed-precision baseline MixQ-GNN compares against, plus the finding that edge-weight quantization can be unnecessary in GCNs.","marker":"[16]"},{"why":"Defines the GCN layer whose nine components MixQ-GNN quantizes and on which node-level experiments are run.","marker":"[17]"},{"why":"Formalizes the message-passing, aggregation, and update schema that Theorem 1's quantized message passing is built on.","marker":"[27]"},{"why":"Provides the integer-arithmetic-only quantization-aware training paradigm, including fake quantization and scale/zero-point arithmetic, that the theorem's derivation uses.","marker":"[30]"},{"why":"Supplies the continuous relaxation over discrete choices, softmax mixing, that MixQ-GNN adapts to search bit-widths.","marker":"[52]"},{"why":"Define the BitOPs efficiency metric used to report the 5.5x and 5.1x reductions.","marker":"[59, 60, 61]"},{"why":"Defines GraphSAGE, the architecture used for the large-scale and node-sampling case studies.","marker":"[28]"},{"why":"Defines GIN, the architecture used for the graph-classification experiments.","marker":"[19]"}],"fun_headline_variants":["Integer-only GNN aggregation matches FP32 exactly","MixQ-GNN cuts GNN bit ops 5.5x with exact integer aggregation","Quantized message passing equals FP32, cuts bit ops 5.5x","Exact integer aggregation for GNNs: 5.5x fewer bit ops","Integer message passing in GNNs: exact FP32 match, 5.5x fewer ops"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The reported efficiency gains assume that the BitOPs metric—a bit-width-weighted count of operations—is proportional to actual inference time, a link the paper validates only on a single message-passing layer, with a moderate 0.59 Pearson correlation on one of the three tested platforms.","fun_headline_variants_meta":{"raw":{"variants":["Integer-only GNN aggregation matches FP32 exactly","MixQ-GNN cuts GNN bit ops 5.5x with exact integer aggregation","Quantized message passing equals FP32, cuts bit ops 5.5x","Exact integer aggregation for GNNs: 5.5x fewer bit ops","Integer message passing in GNNs: exact FP32 match, 5.5x fewer ops"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000832,"raw_usage":{"total_tokens":3679,"prompt_tokens":1040,"completion_tokens":2639,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":656,"completion_tokens_details":{"reasoning_tokens":2533}},"tokens_in":656,"tokens_out":2639,"duration_ms":16340,"temperature":1.0,"reasoning_tokens":2533,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-15T21:36:09.795227+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Measure wall-clock inference time for a full quantized GCN on Cora and GraphSAGE on Reddit at the exact bit-widths MixQ-GNN selects, on the same AMD EPYC and Apple M1 hardware used in Figure 8; if the end-to-end speedup is far below the reported 5.5x BitOPs reduction, the efficiency claim collapses. A separate check: numerically compare $Q_y(AX)$ from the theorem's integer path against $Q_a^f(A)Q_x^f(X)$ for random $A$ and $X$; any disagreement beyond integer rounding would falsify the equality claim.","supporting_citations":[{"cited_title":"How powerful are graph neural networks?,","cited_arxiv_id":null,"evidence_quote":"Defines GIN, the architecture used for the graph-classification experiments."},{"cited_title":"Degree-quant: Quantization-aware training for graph neu- ral networks,","cited_arxiv_id":null,"evidence_quote":"Defines Degree-Quant, the graph-structure-aware quantizer MixQ-GNN integrates and its main baseline, and supplies the claim that high in-degree nodes dominate quantization error."},{"cited_title":"Aggregation-aware quantization for graph neu- ral networks,","cited_arxiv_id":null,"evidence_quote":"Introduces A2Q, the per-node mixed-precision baseline MixQ-GNN compares against, plus the finding that edge-weight quantization can be unnecessary in GCNs."},{"cited_title":"Semi-supervised classification with graph convolutional networks,","cited_arxiv_id":null,"evidence_quote":"Defines the GCN layer whose nine components MixQ-GNN quantizes and on which node-level experiments are run."},{"cited_title":"Neural message passing for quantum chem- istry,","cited_arxiv_id":null,"evidence_quote":"Formalizes the message-passing, aggregation, and update schema that Theorem 1's quantized message passing is built on."},{"cited_title":"Quantization and train- ing of neural networks for efficient integer-arithmetic-only inference,","cited_arxiv_id":null,"evidence_quote":"Provides the integer-arithmetic-only quantization-aware training paradigm, including fake quantization and scale/zero-point arithmetic, that the theorem's derivation uses."},{"cited_title":"DARTS: Differen- tiable architecture search,","cited_arxiv_id":null,"evidence_quote":"Supplies the continuous relaxation over discrete choices, softmax mixing, that MixQ-GNN adapts to search bit-widths."},{"cited_title":"Inductive representation learning on large graphs,","cited_arxiv_id":null,"evidence_quote":"Defines GraphSAGE, the architecture used for the large-scale and node-sampling case studies."}],"review_version":1}