{"id":"ded8a2e4-4d80-4117-9734-f191645d2b2a","arxiv_id":"2608.06812","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":7.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"Using the fact that doubled FP4 values cover a special integer set, the authors build base-13 'limbs' that let FP4 tensor cores exactly emulate integer GEMM and then FP64 DGEMM via Ozaki schemes I and II.","lead":"A new technique lets FP4 (4-bit) AI tensor cores compute double-precision matrix products by rewriting integers in base 13, and its implementation is competitive with, and at large sizes faster than, the prior FP8-based method. It gives scientists a way to keep FP64-class accuracy on GPUs that are dropping their FP64 hardware.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"End-to-end speedup rests on an untuned FP8 baseline; a tuned comparison could erase the 4% advantage.","rationale":"The reader's verdict is CONDITIONAL largely because the performance claim rests on an untuned baseline. I agree. The reader's formal weakest_assumption is hardware exactness of FP4 MMA accumulation; that is a standard property and the paper provides empirical support (bit-exact agreement between OzI and OzII, single-rounding accuracy at phi=0), so I do not think that is the most load-bearing concern. The performance concern is more concrete: the 1.06-1.14x attained-fraction ratio is directly tied to baseline maturity, and the end-to-end 4% advantage could easily be noise or vanish with a tuned baseline. The exactness issue, by contrast, is likely to hold and is testable but not the deciding factor for the verdict. Therefore the central claim of outperformance should remain conditional pending a tuned comparison.","tokens_in":13601,"tokens_out":30368,"duration_ms":244473,"concrete_test":"Re-run the comparison with a tuned GEMMul8-FP8: apply the same epilogue-fusion and launch-overhead reductions used for OzII-FP4 (or vendor-optimized FP8 Ozaki kernels) on the same RTX PRO 6000, and measure compute-stage and end-to-end times at N=4096, 8192, 16384 with at least 30 repetitions to estimate variance. Determine whether the compute-stage speedup falls to <=1.04x and whether the 16384^3 end-to-end time remains below that of GEMMul8-FP8.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central performance claim—OzII-FP4 end-to-end faster than GEMMul8-FP8 at 16384^3—rests on a comparison against a single, unmodified, untuned baseline. Section VII-C states GEMMul8 is 'used as distributed, targeting multiple GPUs, without tuning to this GPU.' The measured compute-stage advantage is 1.10–1.19x, of which the model attributes 1.06–1.14x to a higher attained fraction of peak performance (61–65% vs 53–61%). That attained-fraction gap is precisely the quantity most sensitive to baseline maturity: an FP8 implementation tuned for this GPU with kernel fusion and block-size tuning could close or reverse it. If GEMMul8-FP8 reached even 70% of nominal FP8 peak, its compute-stage equivalent DGEMM throughput would exceed OzII-FP4's 17.31 TFLOPS. The end-to-end advantage at 16384^3 is only 4% (0.96x time), reported as a median of 12 runs with no variance, so it is unclear whether the difference is significant. The mathematical construction is not in question; the robustness of the headline outperformance is.","agreement_with_reader":"disagree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes using FP4 (E2M1) Tensor Cores to emulate FP64 DGEMM through Ozaki schemes I and II. Its core idea is a base-13 limb representation: every E2M1 value doubled is an integer in S={0,±1,±2,±3,±4,±6,±8,±12}, and S covers all residue classes modulo 13, so arbitrary integers can be decomposed into FP4-representable limbs. The authors prove exactness conditions for FP32 accumulation, design a set of 19 moduli for Ozaki scheme II, implement OzI-FP4 and OzII-FP4 as fused Triton kernels, and evaluate on an RTX PRO 6000 Blackwell against GEMMul8-FP8/INT8 and cuBLAS DGEMM. The central claims are that FP4 Tensor Cores can bit-exactly emulate INT8 integer GEMM, that OzII-FP4 has a theoretical 1.04x advantage over an FP8 counterpart when FP4 throughput is twice FP8 throughput, and that the implementation achieves 1.10-1.19x compute-stage speedup and a 0.96x end-to-end time at N=16384^3 relative to GEMMul8-FP8.","tokens_in":13821,"tokens_out":11171,"duration_ms":100641,"significance":"This is a timely and genuinely novel contribution to low-precision emulation of high-precision arithmetic. The base-13 limb representation is elegant, the mathematical lemmas are stated with explicit bounds, the public code is a concrete strength, and the runtime model transparently separates a theoretical throughput factor from an attained-fraction factor. If the performance and exactness claims hold, the paper opens FP4 Tensor Cores to scientific-computing workloads that currently rely on shrinking FP64 units. The main risks are experimental robustness (a single GPU, an untuned baseline, no variance reporting) and an unverified microarchitectural assumption about exact FP32 accumulation in FP4 MMA; these do not undermine the mathematical construction but do affect the headline claims as stated.","major_comments":[{"comment":"The headline end-to-end advantage at 16384^3 is reported as a median of 12 runs, with no variance or confidence interval, and the comparison baseline GEMMul8-FP8 is explicitly described in §VII-C as 'used as distributed, targeting multiple GPUs, without tuning to this GPU.' Since the compute-stage advantage is 1.10-1.19x and the model attributes most of it to a gap in attained fraction of peak performance (61-65% vs 53-61%), the 0.96x end-to-end time at the largest size is fragile. Please report the run-to-run spread (e.g., min-max or standard deviation), test statistical significance, and either tune the FP8 baseline for this GPU or justify why the distributed default is the appropriate comparison. Without this, the claim of 'actually exceeding it' is not yet supported.","section":"§VII-B/C, Table I"},{"comment":"The bit-exactness claims rely on the FP4 MMA instruction performing exact FP32 accumulation with round-to-nearest for values that are exactly representable within the stated ranges. This is an undocumented microarchitectural property; the paper cites the FP32 integer exactness range but does not independently verify the behavior of the FP4 Tensor Core accumulator. Please add a microbenchmark that compares an OzII-FP4 or the INT8-emulation result against a CPU integer GEMM for random inputs at K near the stated bounds (e.g., K=50,000), or cite an authoritative hardware specification. If the accumulator instead truncates or uses an extended internal format, the exactness argument may need revision.","section":"§III Lemma 2, §V Lemma 3"},{"comment":"The accuracy evaluation shows that the proposed method is at most 0.9 bit better than GEMMul8-FP8 at small exponent spreads (φ≤4) but up to 1.5 bits worse at φ≥8, with a steeper degradation (5.9 bits from φ=0 to φ=32 versus 3.5 bits for the FP8 version). The conclusion's statement that the method 'kept accuracy at or above the DGEMM level' therefore needs qualification: this holds for modest dynamic ranges within a row, but for wide exponent spreads the effective accuracy is below the FP8-based Ozaki implementation and below ideal FP64 rounding. Please state this limitation explicitly in the abstract or conclusion, or provide evidence that the test distribution is representative of target workloads.","section":"§VII-A, Fig. 6, Conclusion"}],"minor_comments":[{"comment":"The proof of the gap-free range is only sketched as 'by induction'; please include the induction step explicitly or refer to an appendix, since the bound X_p=(13^p-1)/3 is used in the limb-count arguments.","section":"§III, Lemma 1"},{"comment":"The exhaustive verification producing the exceptional two-limb moduli {115,117,143,169} is not described; please state the search method or provide the checking code, so readers can reproduce the modulus list.","section":"§V-A"},{"comment":"Please clarify whether the maximum error is taken over one 128x128 output tile or over multiple random matrices, and specify the number of trials and random seed; this affects the interpretation of the smooth degradation curves.","section":"§VII-A, Fig. 6"},{"comment":"The model's memory-bound term D/β would benefit from an explicit definition of D for each method, since the preprocessing bytes moved are central to the end-to-end comparison.","section":"§VII-C, Eq. (4)"},{"comment":"The abstract contains '163843' where a superscript is intended; this should be typeset as 16384^3.","section":"Abstract"}],"recommendation":"major_revision","confidential_remarks":"The paper makes a valuable mathematical and systems contribution, and the core construction appears sound. My main reservations are the fragility of the performance claim (4% end-to-end advantage against an untuned baseline, no variance) and the unverified hardware assumption behind bit-exactness; both are fixable with additional experiments and should be addressed before publication. The integration of INT8 emulation and the public code are strong points that support eventual acceptance after revision."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"The base-13 limb representation is the real contribution here. It is a clean idea, proved carefully, and it removes the specific reason prior Ozaki-scheme work rejected FP4: intermediate sums no longer need to live in FP4. The bit-exact INT8 GEMM emulation is a nice bonus. I checked the counting and the exactness bounds in Sections III-V; Lemma 3's four conditions are correctly stated and the 3.6x margin over the tested inner-product length is comfortable. The mathematical core holds up.\n\nThe implementation work is also substantial. Epilogue fusion for the 19-moduli residue GEMMs, fused limb decomposition, and exact single-pass CRT in integer arithmetic are all sensible and well explained. The runtime model is honest: it separates the theoretical 1.04 advantage (from FP4:FP8 throughput ratio and GEMM counts) from the 1.06-1.14 attained-peak gap, and the measurements track the model well.\n\nThe soft spot is the performance headline, not the math. The end-to-end advantage at 16384 is 4% (0.96x time) against GEMMul8-FP8, which the paper itself says is used unmodified and untuned for this single GPU. Attained fraction of peak is exactly the quantity most sensitive to baseline maturity, so a tuned FP8 baseline could close or reverse that edge. Twelve runs with no variance on one GPU is also thin evidence for a 4% difference. That said, the authors do not oversell: they report the compute-stage advantage of 1.10-1.19x separately, explain the decomposition, and provide source code. The accuracy evaluation is more solid, with bit-for-bit agreement between OzI-FP4 and OzII-FP4 and single-rounding accuracy at phi=0.\n\nThe only assumption I would want flagged more prominently is that FP32 accumulate on these tensor cores is exact over the stated integer range. That is standard for this line of work, and the paper gives a range with margin, but it is not independently verified on this specific hardware. Minor, not disqualifying.\n\nWho is this for? Numerical library developers and researchers working on low-precision tensor core emulation. It deserves a serious referee rather than a desk reject. I would send it out with a request for a tuned baseline and variance reporting, but the central idea is publishable and likely to be built on.","headline":"The base-13 limb representation is a genuinely new and correct idea that makes FP4 tensor cores usable for DGEMM emulation; the measurement story is plausible but the headline performance edge is thinner than the paper's framing suggests.","tokens_in":14344,"tokens_out":1426,"would_cite":true,"duration_ms":13833,"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":"FP4 tensor cores, via a base-13 limb representation of integers, can compute FP64-class matrix products exactly, with an FP4 Ozaki-scheme II implementation that outperforms the FP8 baseline on Blackwell hardware.","keywords":["matrix multiplication","DGEMM emulation","mixed precision","Ozaki scheme","FP4","Tensor Cores","GPU","base-13 limb representation"],"falsifier":"Run a microbenchmark on the same GPU architecture: choose limb vectors whose squared values sum to exactly $2^{24}+1$ with inner-product length below 58,254, execute the FP4 MMA, and compare every output element to a reference arbitrary-precision integer computation; if any element is off by one or more, the FP32 accumulator rounds inside the claimed exact range, falsifying the exactness premise. A simpler variant is to check whether the accumulator preserves the exact sum of integers up to $2^{24}$ at all.","tokens_in":13439,"feed_emoji":"🧮","tokens_out":10930,"duration_ms":80245,"temperature":0.7,"pith_summary":"The paper establishes that FP4 (E2M1) Tensor Cores—the fastest but lowest-precision matrix units on current GPUs—can perform exact integer matrix multiplication and, on top of it, emulate FP64 matrix multiplication (DGEMM) without introducing any error of their own. The enabling observation is that every FP4 value doubled is one of the integers in $S=\\{0,\\pm1,\\pm2,\\pm3,\\pm4,\\pm6,\\pm8,\\pm12\\}$, and that this set shifted by multiples of 13 covers all integers, so any integer can be written in base 13 with FP4-representable digits called limbs. Using this representation, the paper builds both Ozaki schemes I and II on FP4 Tensor Cores, answering the earlier objection that FP4's single mantissa bit makes intermediate sums unusable. On a Blackwell-generation GPU, the FP4 version of Ozaki scheme II matches the accuracy of an existing FP8-based implementation while running 1.10–1.19 times faster in the compute stage and, at problem size $16384^3$, faster end to end; the result is exact with respect to the integer-converted inputs.","feed_headline":"Base-13 limb method makes FP4 tensor cores beat FP8 at FP64 GEMM","feed_subtitle":"On Blackwell, the FP4 Ozaki-II scheme is 1.10–1.19x faster in compute and wins end-to-end at 16384^3.","key_machinery":"The load-bearing object is the base-13 FP4 limb representation. Every E2M1 value, doubled, is one of $S=\\{0,\\pm1,\\pm2,\\pm3,\\pm4,\\pm6,\\pm8,\\pm12\\}$; Lemma 1 shows that $S$ shifted by multiples of 13 covers all integers, so an arbitrary integer can be written as $N=\\sum 13^i c_i$ with greedy representatives $|c_i|\\le 8$. The representation turns arbitrary integers into sequences of FP4-representable coefficients before any GEMM; the FP4 MMA multiplies stored halves, so each partial product contributes $c_i c_j/4$, and a $\\times2^2$ correction together with the base-13 weights reconstructs the integer product exactly. The same device supplies the exactness bounds (Lemmas 2 and 3) by keeping every intermediate sum inside the FP32 accumulator's exact-integer range, with the Ozaki scheme II cross-term accumulation giving the tightest limit $K\\le 58{,}254$.","core_discovery":"The central discovery is that the sparse 16-value set of E2M1 FP4, which cannot represent integers directly, becomes the integer set $S=\\{0,\\pm1,\\pm2,\\pm3,\\pm4,\\pm6,\\pm8,\\pm12\\}$ when every value is doubled, and that this set, shifted by all multiples of 13, covers every integer. From this the paper constructs a positional base-13 limb representation: any integer $N$ decomposes as $N=\\sum_{i=0}^{p-1} 13^i c_i$ with $c_i\\in S$, each limb stored as the E2M1 value $c_i/2$. Because the greedy conversion keeps $|c_i|\\le 8$, limb products are at most 64, so inner products over lengths up to 116,508 (Ozaki scheme I) or 58,254 (Ozaki scheme II, cross-term bound) stay inside the integer-exact range of the FP32 accumulator; the FP4 Tensor Core GEMM therefore performs an exact integer GEMM. On this base the paper constructs both Ozaki schemes, with the FP4 version of scheme II using 19 carefully chosen two-limb moduli ($169,115,113,\\ldots,53$) whose product exceeds $2^{123}$, requiring 75 FP4 GEMMs and an exact single-pass CRT reconstruction in integer arithmetic. On a Blackwell-generation GPU, this implementation is 1.10–1.19 times faster in the compute stage than the existing FP8-based Ozaki scheme II implementation, and end to end it is faster at $16384^3$; the paper attributes the gap to a theoretical factor of 1.04 from FP4's 2:1 throughput advantage versus the 75/39 GEMM-count ratio, multiplied by a higher attained fraction of peak performance from kernel fusion.","pith_inferences":["The representation scheme is not tied to E2M1's particular value list; any low-precision format whose value set is an affine image of a small integer set could get an analogous exact limb decomposition with a different base, so the idea may transfer to future formats.","If future GPUs push the FP4-to-FP8 throughput ratio beyond the break-even value of about 1.9 derived here, the theoretical advantage of FP4-based Ozaki scheme II over FP8 would widen, making this kind of emulation an increasingly attractive substitute on hardware that cuts FP64 and INT8 units.","A direct test of the FP32 accumulator's exact-integer range on shipped hardware, independent of the paper's setup, would settle whether the bit-exact claims hold beyond the one GPU generation measured here.","The bit-exact emulation of integer GEMM with nine FP4 GEMMs suggests FP4 Tensor Cores could also substitute for missing INT8 units on accelerators that only provide FP4/FP8 paths, apart from FP64 emulation."],"forward_implications":["INT8 Tensor Core integer GEMM can be reproduced bit-exactly on FP4 Tensor Cores alone, using three limbs per operand and nine FP4 GEMMs.","Both Ozaki scheme I and scheme II admit FP4 versions; the scheme II version needs 19 moduli and 75 FP4 GEMMs for the FP64 mantissa, with exact reconstruction by an integer direct CRT.","On hardware with FP4 at twice the throughput of FP8, the FP4 Ozaki scheme II has a theoretical compute-stage advantage of 1.04x over the FP8 version, independent of implementation tuning.","Measured on a Blackwell-generation GPU, the FP4 implementation is 1.10–1.19x faster than the FP8 baseline in the compute stage across all tested sizes and is faster end to end at $16384^3$, while the output is exact relative to the integer-converted inputs."],"supporting_citations":[{"why":"Defines the original Ozaki scheme I error-free transformation on which the FP4 adaptation is built.","marker":"[5]"},{"why":"Defines Ozaki scheme II, the residue-number-system/CRT method that the FP4 adaptation extends with a new modulus set.","marker":"[6]"},{"why":"The FP8-quantized Ozaki scheme II study that rejected FP4 because intermediate sums round; its 13-modulus configuration and GEMM count are the comparison baseline for the FP4 scheme.","marker":"[7]"},{"why":"The public FP8/INT8 implementation of Ozaki scheme II that serves as the measured performance baseline.","marker":"[8]"}],"fun_headline_variants":["FP4 tensor cores outrun FP8 on FP64 GEMM via base-13 limbs","Base-13 limb trick lets FP4 tensor cores beat FP8 for DGEMM","FP4 tensor cores emulate FP64 GEMM: base-13 limbs outperform FP8","FP4 cores crack FP64 GEMM: base-13 limbs beat FP8 on Blackwell","Base-13 FP4 limb scheme: faster than FP8 for FP64 GEMM on Blackwell"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The bit-exactness claims rest on the assumption that the FP4 Tensor Core hardware multiplies the stored FP4 values exactly and accumulates the weighted sums in FP32 registers without any rounding for inner-product lengths up to 58,254 (and up to 116,508 for Ozaki scheme I); if the microarchitecture rounds anywhere inside that range, the exactness proofs no longer apply.","fun_headline_variants_meta":{"raw":{"variants":["FP4 tensor cores outrun FP8 on FP64 GEMM via base-13 limbs","Base-13 limb trick lets FP4 tensor cores beat FP8 for DGEMM","FP4 tensor cores emulate FP64 GEMM: base-13 limbs outperform FP8","FP4 cores crack FP64 GEMM: base-13 limbs beat FP8 on Blackwell","Base-13 FP4 limb scheme: faster than FP8 for FP64 GEMM on Blackwell"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000852,"raw_usage":{"total_tokens":3849,"prompt_tokens":1233,"completion_tokens":2616,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":849,"completion_tokens_details":{"reasoning_tokens":2501}},"tokens_in":849,"tokens_out":2616,"duration_ms":14585,"temperature":1.0,"reasoning_tokens":2501,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-15T14:28:44.025306+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run a microbenchmark on the same GPU architecture: choose limb vectors whose squared values sum to exactly $2^{24}+1$ with inner-product length below 58,254, execute the FP4 MMA, and compare every output element to a reference arbitrary-precision integer computation; if any element is off by one or more, the FP32 accumulator rounds inside the claimed exact range, falsifying the exactness premise. A simpler variant is to check whether the accumulator preserves the exact sum of integers up to $2^{24}$ at all.","supporting_citations":[{"cited_title":"Error-free trans- formations of matrix multiplication by using fast routines of matrix multiplication and its applications,","cited_arxiv_id":null,"evidence_quote":"Defines the original Ozaki scheme I error-free transformation on which the FP4 adaptation is built."},{"cited_title":"GEMMul8 (GEMMulate): GEMM emulation and its extension to BLAS-like matrix operations using INT8/FP8 matrix engines based on the Ozaki scheme II,","cited_arxiv_id":null,"evidence_quote":"The public FP8/INT8 implementation of Ozaki scheme II that serves as the measured performance baseline."}],"review_version":2}