acceptodds
Under review as a conference paper at ICLR 2027

ApexQuant: Data-Free Elastic Quantization by Residual Re-Isotropization

Abstract

We introduce ApexQuant, a calibration-free quantization method that recursively re-quantizes the residual error, serving as a refinement layer on top of existing quantizers. We establish that a fresh random rotation returns each residual to the uniform distribution on the hypersphere, which characterizes the rate of progressive error decay across successive passes. This result lets us determine, before any weight is read, how many passes a layer needs for a target weight-space error. Every prefix is itself a valid lower-rate model, so one artifact serves several precisions. We instantiate ApexQuant with three interchangeable stages, scalar, and trellis, and validate it on four open-weight LLMs and on Earth-observation and medical domains where in-distribution data is often unattainable as imagery arrives under restrictive licences or due to patient material under privacy constraints. Progressive re-isotropization comes within a few percent of full precision at four bits and gives the best two-bit arm we measure, in a completely data-free setting.

Primary area:
other topics in machine learning (i.e., none of the above)
Keywords:
Quantization, Data-free quantization, LLMs

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_1zXoOpenReview ↗
Rating
3
Confidence
4
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes ApexQuant, a calibration-free elastic quantization framework that progressively quantizes residual errors using independent random rotations and reusable codebooks, supported by a theoretical analysis of geometric error decay. Experiments across language, remote-sensing, and medical models demonstrate competitive quantization performance.

Critical strengths
  1. The paper provides a theoretically grounded formulation of residual re-isotropization and progressive error decay.
  2. ApexQuant supports multiple precision levels through a single nested representation and accommodates scalar, E8 lattice, and trellis quantizers. This flexibility is valuable for memory-constrained deployments
  3. The experiments cover several language models and two additional application domains, with comparisons against multiple data-free quantization methods.
Critical weaknesses
  1. Despite achieving the lowest KL divergence among the evaluated data-free baselines at approximately 2 bits per weight, ApexQuant still suffers substantial degradation in downstream performance on several models.
  2. The central theoretical guarantees rely on independently sampled Haar-random orthogonal rotations, whereas the implementation adopts randomized Hadamard transforms for computational efficiency. The authors empirically demonstrate that the discrepancy is small on evaluated models, but no corresponding theoretical error bound is established for the practical transform.
  3. The reported 1.56× decoding speedup is obtained using a simulated Mistral block stack rather than a complete autoregressive inference pipeline. The reported speedup may not directly translate into comparable improvements in real-world LLM serving.
  4. The empirical comparison with existing elastic quantization methods is not fully controlled. Several comparisons in Appendix G rely on previously published results rather than unified reproduction.
Questions for authors
  1. Given the substantial performance degradation observed on several models at approximately 2 bits per weight, could the authors clarify which practical deployment scenarios can tolerate this level of degradation?
  2. Can the authors provide theoretical error bounds or a more systematic sensitivity analysis for replacing Haar-random rotations with randomized Hadamard transforms?
  3. How does ApexQuant perform in a complete LLM inference pipeline, including attention, KV-cache operations, and prefill? Could the authors report end-to-end latency, throughput, and peak GPU memory consumption under realistic batch sizes and mixed-precision serving workloads?
  4. Could the authors provide a more controlled comparison against representative elastic quantization methods under consistent models, evaluation datasets, and storage budgets?
2 comments
AuthorsOpenReview ↗

2-bit cost and Hadamard vs. Haar

Thank you for the thorough reading and the constructive questions. We are glad you found the theoretical formulation grounded and the flexibility of the nested representation valuable for memory-constrained deployments.

W1. The cost of data-free quantization at 2 bits

You are right about substantial downstream degradation at two bits for some models. After diving deeper in this direction, we realized that at this bit-width, quality depends as much on the geometry of the weights as on the quantization method, and this has an information-theoretic explanation. For a linear layer with weights WW and inputs xx, the output distortion of a quantized layer W^\hat W is the proxy loss Ex∥(W^−W)x∥2=tr⁡((W^−W)H(W^−W)⊤)\mathbb{E}_x \Vert (\hat W - W)x \Vert^2 = \operatorname{tr}\bigl((\hat W - W) H (\hat W - W)^\top\bigr), where H=Ex[xx⊤]H = \mathbb{E}_x[xx^\top] is the second-moment matrix (Hessian) of the layer inputs. A calibrated quantizer such as QTIP estimates HH and can approach a distortion that scales with the geometric mean λ~\tilde\lambda of the eigenvalues of HH, which lower-bounds what Hessian-aware rounding achieves (Gersho & Gray, 1992; Chee et al., 2023). A data-free quantizer, however, cannot know which directions are sensitive. The random rotations in ApexQuant deliberately isotropize the error, spreading it evenly across all directions. The distortion therefore scales, up to a correction along the direction of the weights themselves, with the average eigenvalue λˉ=tr⁡(H)/d\bar\lambda = \operatorname{tr}(H)/d. The ratio λˉ/λ~\bar\lambda / \tilde\lambda is therefore a fixed penalty, and because each additional bit reduces distortion by a factor of four, the cost of forgoing calibration is approximately G=12log⁡2(λˉ/λ~)G = \tfrac{1}{2}\log_2(\bar\lambda/\tilde\lambda) bits (Jayant & Noll, 1984; Goyal, 2001). This is a high-rate approximation and at two GG is an upper bound on the penalty.

This may explain why the penalty varies across models. We expect it to depend on how spread out the eigenvalues of HH are. This would explain why the encoders Clay and UNI keep most of their accuracy at two bits (Table 4) while LLaMA2 does not, although we have not measured this spread directly. For LLaMA2-7B (Table 10), ApexQuant at 4 bits (perplexity 5.61) performs comparably to QTIP at 2 bits (perplexity 5.86), suggesting that the penalty GG for this model is at most roughly two bits, since this gap also includes ApexQuant's per-pass rate loss and QTIP's inter-block feedback.

We have added this discussion to the Limitations section, together with a recommendation of four bits and above as standalone tiers, where accuracy stays close to full precision without any data. The 2-bit tier remains useful as a prefix of the 4-bit model, for example as a fallback under memory pressure or for progressive download, and on some models it retains most of the performance (84.9% of the full-precision above-chance accuracy margin on Qwen2.5-7B in our zero-shot results). In our new experiments the 2-bit prefix also remains usable on the MoE model Qwen3.5-35B-A3B with an MMLU of 0.718, while the other data-free methods fall to chance. On Llama-3.1-8B it is not usable, and on the BFCL tool-calling benchmark it halves the score. These results are consistent with this recommendation.

W2. Haar in theory, Hadamard in practice

Thank you for this comment. Recent work has closed most of this gap and we have updated the manuscript to highlight this (Section 3). A single randomized Hadamard transform behaves like a random rotation for flat inputs, and two composed transforms do so for every input (Ben-Basat et al., 2026; Zilca & Mendelson, 2026). For our scalar stage these results carry over directly to the per-pass error and therefore to the decay law. Only the first pass sees the raw weights; after it the residual is approximately flat, which is the regime the single-transform bound covers. This matches our measurements: the per-pass ratio departs from the Haar prediction by at most 1.6% on individual layers at the first pass and by less than three parts in ten thousand at every later pass. Composing two transforms per pass is a cheap option where a guarantee for the first pass is needed. On real weights the difference is small and replacing the Hadamard transform by a dense random rotation changes the layer error by at most 0.2%, on both Clay and Phi-1.5 and at both group sizes we use (d=256d=256 and 512512). For the E8E_8 lattice the same guarantee holds with three composed transforms (Ben-Basat et al., 2026). For the trellis no such result is known and the agreement remains empirical, which we state as a limitation. The first layer of Llama-3.1-70B is the one case where we needed an exception (see W3), and we have not yet tested whether composing transforms removes it.

AuthorsOpenReview ↗

End-to-end serving and elastic baselines

W3. End-to-end serving

We agree that the block-stack benchmark in Table 11 offers only a limited view of end-to-end serving. It measures the linear layers of a 32-block stack at a single decode step and does not include attention, the KV cache or prefill. We now state this in the main text. We also make clear that the 1.56×1.56\times speedup is measured against storing one artifact per precision and not against FP16.

To evaluate the complete pipeline we integrated ApexQuant into vLLM as a quantization plugin. Attention, KV cache, prefill and batching are therefore handled by vLLM itself. The table below summarizes the results, which we report in a new appendix. On both models the 4-bit and 6-bit tiers stay close to BF16. On a single B200 GPU the 70B weights take 38.0 GiB at four bits instead of 131.4 GiB. This frees memory for the KV cache, which grows from 94k to 318k tokens and allows larger batches. For the 70B model the first layer has to be kept in BF16, which adds 0.15 bits per weight. Without it the 2-bit and 4-bit tiers collapse and we report this in the Limitations section.

ModelPrecisionMMLUWeightsKV cache (tokens)
Llama-3.1-8BBF160.683––
4-bit0.671––
6-bit0.682––
Llama-3.1-70BBF160.825131.4 GiB94k
4-bit0.82338.0 GiB318k
6-bit0.82554.3 GiB303k

The plugin does not yet use the fused kernels of Table 11 and in its current form it is slower than BF16. We therefore do not report its throughput and our latency claims remain limited to the fused-kernel measurement. Porting the fused kernels into vLLM is future work and we have noted this in the Limitations section.

W4. Controlled comparison with elastic methods

Of the elastic methods, only Any-Precision LLM has released code, and we reproduced it with the authors' own pipeline under our evaluation protocol (Table 10). At four bits ApexQuant reaches a perplexity of 5.613 against 5.624, without any data, while at two bits Any-Precision LLM is better (35.21 against 71.80). The same reproduction shows why published numbers must be used with care: the values reported for Any-Precision LLM by Wang et al. (2026) (6.05 and 2⋅1032\cdot10^3) do not match the 5.624 and 35.21 we obtain. MoBiQuant and AnyBCQ have not released code, so we can only report their published values, which we flag in the table. MatQuant requires quantization-aware training on 10–100M tokens and is therefore outside the post-training setting. In a new appendix we also compare all methods under one protocol on Llama-3.1-8B and two MoE models, including the calibrated GPTQ and AWQ and the data-free DASHQuant, SINQ and HQQ. At four bits ApexQuant has the lowest KL among methods with comparable storage.

We thank you again for the constructive questions. We hope the new end-to-end results and clarifications address your concerns.

References

  • A. Gersho and R. M. Gray, Vector Quantization and Signal Compression, Kluwer, 1992.
  • J. Chee, Y. Cai, V. Kuleshov, and C. De Sa, "QuIP: 2-Bit Quantization of Large Language Models With Guarantees," NeurIPS, 2023.
  • N. S. Jayant and P. Noll, Digital Coding of Waveforms, Prentice Hall, 1984.
  • V. K. Goyal, "Theoretical Foundations of Transform Coding," IEEE Signal Processing Magazine, 18(5), 2001.
  • R. Ben-Basat, W. Kuszmaul, M. Mitzenmacher, A. Portnoy, and S. Vargaftik, "Quantizing With Randomized Hadamard Transforms: Efficient Heuristic Now Proven," arXiv:2605.06014, 2026.
  • T. Zilca and G. Mendelson, "Approximating Uniform Random Rotations by Two-Stage Structured Hadamard Rotations in High Dimensions," arXiv:2604.23418, 2026.
Reviewer_s1bYOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes ApexQuant, a calibration-free elastic quantization framework that progressively quantizes residual errors through independent random rotations. Based on the re-isotropization property of Haar rotations, the authors derive a geometric error decay law that enables predicting the required quantization passes without accessing model weights. ApexQuant supports scalar, E8 lattice, and trellis quantizers while providing nested representations for multiple precision levels. Experiments on language and vision models demonstrate competitive quantization performance.

Critical strengths

(1) ApexQuant achieves multiple precision levels without requiring calibration data or storing separate quantized models, which is useful for deployment scenarios with restricted data access or varying memory budgets.

(2) ApexQuant supports scalar Lloyd–Max, E8 lattice, and trellis quantizers within a unified progressive quantization pipeline, enabling flexible integration with different quantization methods.

Critical weaknesses

(1) The proposed decay law characterizes expected weight reconstruction error, but model performance depends on the sensitivity of different layers and directions to quantization perturbations. Consequently, the theoretically predicted number of refinement passes may not provide an optimal allocation for preserving model accuracy.

(2) Although ApexQuant performs favorably relative to calibration-free baselines at approximately 2 bits, its absolute model quality can still degrade considerably. For instance, the trellis variant attains a perplexity of 71.80 on LLaMA2-7B at 2 bits, versus 5.86 for the calibrated QTIP method. Therefore, the practical utility of the lowest-precision tier in real-world deployment remains unclear.

(3) The 1.56× decoding speedup is measured using a synthetic Mistral block-stack benchmark rather than a complete LLM inference pipeline. The evaluation excludes attention, KV-cache operations, and prefill computation, and the latency improvements depend on the batch regime. Therefore, it remains unclear how much of the reported acceleration translates into realistic end-to-end inference workloads.

Questions for authors

Please address the above concerns.

1 comment
AuthorsOpenReview ↗

Model sensitivity, 2-bit tier and serving

Thank you for the detailed reading and the constructive feedback.

W1. Weight-space error vs. model performance

Thank you, this is an important point. We agree that in the paper the decay law describes the expected weight error, and that layers differ in sensitivity. This is why we use the KL divergence to the full-precision model, not the weight error, as the primary metric throughout the paper and there ApexQuant has the lowest KL among the data-free baselines at matched storage.

Having said that, the decay is not restricted to unweighted weight error. Because the fresh rotation makes the residual error approximately isotropic, a curvature-weighted error, for example under the Fisher information, which governs the KL divergence of the outputs to second order, decays at approximately the same rate, up to a correction of relative order ρ2\rho^2 along the direction of the weights themselves. The predicted depth is therefore directionally correct in output space, not only in weight space. This can be observed in Table 4, where the KL divergence of both encoders falls by roughly an order of magnitude per pass (0.641, 0.033, 0.003 on UNI).

We agree, however, that the same number of passes in every layer is not necessarily the best allocation for accuracy. The decay law gives the error of each layer as a function of its number of passes, so it can be combined with any per-layer sensitivity score. In the appendix on the calibration pass we test such an allocation. On Clay it reaches a lower embedding error than three uniform passes with 1.2 fewer bits per weight, but it does not improve EuroSAT accuracy and it does not help on language models. We now report this as an open problem.

W2. The cost of data-free quantization at 2 bits

You are right that ApexQuant can still degrade considerably at two bits. Reviewer 1zXo raised the same point and we give the full answer in our response to them (W1). In short, without calibration data a quantizer cannot know which directions of the weights are most sensitive, and this costs a number of bits that depends on the model. On LLaMA2-7B our 4-bit model already outperforms QTIP at 2 bits, so this cost is at most about two bits there. We therefore recommend four bits and above as standalone tiers and have added this to the Limitations section. The 2-bit tier remains useful as a free prefix of the 4-bit model, and on some models it stays usable, for example with an MMLU of 0.718 on the MoE model Qwen3.5-35B-A3B.

W3. End-to-end serving

We agree that the block-stack benchmark in Table 11 offers only a limited view of end-to-end serving. It measures the linear layers of a 32-block stack at a single decode step and does not include attention, the KV cache or prefill. We now state this in the main text. As you note, the latency gain also depends on the batch regime. When decoding is memory-bound a mixed batch costs the same as serving every request at premium precision, so the 1.56×1.56\times advantage over storing one artifact per precision requires a large batch. The 1.67×1.67\times storage saving holds in every regime. Prefill is compute-bound and there a PP-pass layer performs PP times the dequantize-multiply work, so the latency advantage is specific to decoding.

To evaluate the complete pipeline we integrated ApexQuant into vLLM, which handles attention, KV cache, prefill and batching. The results are summarized in a table in our response to Reviewer 1zXo (W3). The 4-bit and 6-bit tiers stay close to BF16 on Llama-3.1-8B and Llama-3.1-70B, where the first layer of the 70B model is kept in BF16. At four bits the 70B weights take 38.0 GiB instead of 131.4 GiB. The plugin does not yet use the fused kernels of Table 11 and is currently slower than BF16, so our latency claims remain limited to the fused-kernel measurement.

Following your comment on presentation, we will also revise the theory section to make it easier to follow. We thank you again for the constructive feedback. We hope the new end-to-end results and clarifications address your concerns.

Reviewer_PAgsOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The authors propose ApexQuant, a quantization method that provides calibration-free elasticity through residual quantization with a fresh random rotation at every pass. Corollary 1 establish the theoretical benefits of these refresh rotations, and Proposition 2 proposes a progressive decay law to accurately predict the expected weight-space error. Empirical experiments indicate that ApexQuant outperforms calibration-free baselines across language tasks (Tables 3) and works for vision tasks (Table 4).

Critical strengths
  1. The idea of residual re-isotropization may have broader applicability, and can potentially be applied to other methods that relies on the residual quantization mechanism.
    1. However, there is a related contemporaneous work: https://arxiv.org/abs/2605.13810, which also applies a fresh randomized Hadamard transform to a quantization residual. Besides, you may want to add LiftQuant to Table 1, although it's also contemporaneous work.
Critical weaknesses
  1. The motivation of avoiding "calibration-data bias" is questionable. Even if the exact data used to train the model is unattainable, we can just use public calibration data or representative deployment samples. In fact, most calibration-dependent PTQ methods perform quite well even using a different calibration set, e.g., QuIP# and QTIP use Redpajama, but the paper does not establish when avoiding calibration provides a practical advantage.
  2. Sharing prefixes does reduce storage, but I'm also not sure who needs to serve multiple bit rates of the same model at the same time. In addition, Table 11 doesn't really show a big difference between C (ApexQuant) and D (Homogeneous premium batch, i.e., serve the highest precision).
Questions for authors
  1. Which deployment conditions make calibration-free elasticity advantageous? There are prior work on "calibration-free" and "elasticity", and the applications are already niche for either, so the intersection between these applications could be even more niche. As the manuscript pointed out, ApexQuant is the first calibration-free elastic method, indicating this problem hasn't got a lot of attention, but why does it worth attention?
    1. Table 11 is an attempt at answering this question with a practical deployment setting, but it isn't satisfactory because (i) the advantage of D over C isn't clear, and (ii) it doesn't explain why we want to be calibration-free.
2 comments
AuthorsOpenReview ↗

Related work and calibration bias

Thanks a lot for pointing out the contemporaneous work LiftQuant and DASHQuant, we have added them to Table 1.

While DASHQuant also applies a fresh Hadamard rotation to the residual it only does it once as a second stage. ApexQuant draws a fresh rotation at every pass with the same quantizer and this makes the error of every prefix follow a predictable decay law. Therefore the main advantage is that one file serves several precisions and the error at each of them can be determined in advance. In our new experiments ApexQuant also has a lower KL than DASHQuant at four bits on every model we tested, for example 0.038 against 0.083 on Llama-3.1-8B. LiftQuant reaches fractional bit-widths such as 2.4 bits but each bit-width is a separate model that requires calibration data and fine-tuning. ApexQuant reaches fine-grained bit-widths from a single file and without any data by choosing the number of passes per layer.

Motivation for avoiding calibration-data bias

Indeed, a public corpus such as RedPajama works well for generic English deployments. For specialized languages and domains, however, a suitable dataset for running a calibrated quantizer is often unavailable. Satellite imagery, for example, varies widely in its spectral bands, and some hyperspectral missions such as Planet's Tanager record over 400 bands, so gathering representative calibration data for such domains can be difficult. Similarly, sensitive medical records is often restricted to the collecting hospital, and in these cases the party that runs the quantizer typically holds the weights but not the domain data.

Even where calibration data exists, a calibrated quantizer fits the distribution it was calibrated on. We show this in a new experiment on two clinical variants of Llama-3.1-8B. We measure the KL divergence to the unquantized model on four corpora, namely PubMed, WikiText, code and Danish. When GPTQ is calibrated on in-domain medical text instead of C4, its KL improves on PubMed from 0.046 to 0.029 but gets worse on WikiText from 0.056 to 0.069 and on Danish from 0.114 to 0.129. On the second variant it also lowers MedQA accuracy from 0.588 to 0.511. ApexQuant uses no data and has the lowest KL on all four corpora among the data-free and C4-calibrated methods at four bits. Only the in-domain GPTQ is lower and only on PubMed. On Llama-3.1-8B in general ApexQuant at four bits also reaches a lower KL and a higher MMLU than both GPTQ and AWQ.

Our data-free quantizer also applies unchanged to any weight matrix, including Mixture-of-Experts and multimodal architectures, without architecture-specific calibration pipelines. It is also fast, as our encoder quantizes a 7B model in about 35 seconds per pass on one RTX 4090.

Second, the quantization step itself can become an attack surface. Recent work shows that a clean full-precision model can be backdoored through the quantization step using a small calibration set (Chen et al., 2026a), and that this attack extends to LLMs (Chen et al., 2026b). A data-free approach removes this calibration-based route, although attacks that act on the weights alone remain possible.

AuthorsOpenReview ↗

Calibration-free elasticity and Table 11

Calibration-free elasticity

Calibration-free elasticity is highly desirable in several practical settings.

In practice, the same model is often deployed across a wide range of hardware and operating conditions. Facebook, for example, reports that its deep learning models run on more than two thousand unique SoCs across over one billion mobile devices (Wu et al., 2019). In such settings a single artifact lets each device read the prefix that fits its memory, download it progressively and upgrade in place by appending passes. ApexQuant also offers fine-grained bit-width control, so precision can be set to fully use the available memory or to meet a target level of performance.

Mixture-of-Experts (MoE) models are another important use case. Routing is sparse and uneven, so a small set of experts processes most tokens while many others are rarely activated. Since MoE models hold far more parameters than they activate per token, memory rather than compute is often the bottleneck. An elastic quantizer can therefore give each expert a bit-width that reflects its routing frequency and the memory budget (Huang et al., 2025). Routing imbalance also makes calibration unreliable for MoE models, as rarely activated experts receive very few calibration tokens and their Hessian estimates are noisy (Huang et al., 2025). ApexQuant needs no calibration data, so its quality does not depend on how tokens are routed. Our new experiments on the MoE model Qwen3.5-35B-A3B support this. At four bits ApexQuant reaches an MMLU of 0.819 with a lower KL than all data-free baselines, and on the BFCL tool-calling benchmark it scores 48.4% against 50.0% for BF16. At two bits it still reaches an MMLU of 0.718 while the other data-free methods fall to chance.

Finally, elastic quantization is a very active research direction (Any-Precision LLM, MatQuant, MoBiQuant, LiftQuant, RRQ), yet nearly all existing methods require calibration or training data. To our knowledge, ApexQuant is the first data-free elastic approach. Moreover, we theoretically establish an error decay law that predicts the quality of every precision level before any weights are quantized.

Table 11

You are right that at decode a mixed batch costs about the same as serving every request at premium precision. If the premium tier fits in memory, serving every request at premium is the best choice and ApexQuant supports this from the same file. Table 11 shows that mixing precisions in one batch adds almost no cost, as the two lower-precision requests add 0.49 ms against roughly 9 ms when served on their own. It does not show that tiering is faster than serving only premium requests. The latency gain of nesting is against storing one artifact per precision, where it is 1.56×1.56\times faster and 1.67×1.67\times smaller. The lower tiers are useful when the premium tier does not fit or is not free. This is the case on devices with less memory, on a server that needs to free memory for the KV cache without reloading the model, and in compute-bound settings such as large batches and prefill where each extra pass adds work. We will clarify this in the revised paper.

We have strengthened the motivation and improved clarity following your advice. We hope these clarifications address your concerns about the motivation and usefulness of ApexQuant, and that you will consider raising your score.

References

  • C.-J. Wu et al., "Machine Learning at Facebook: Understanding Inference at the Edge," HPCA, 2019.
  • W. Huang et al., "Mixture Compressor for Mixture-of-Experts LLMs Gains More," ICLR, 2025.
  • X. Chen, P. Zhang, J. Sun, W. Wang, and J. Wang, "Rounding-Guided Backdoor Injection in Deep Learning Model Quantization," NDSS, 2026.
  • X. Chen, P. Zhang, J. Sun, J. S. Dong, W. Wang, and J. Wang, "LLMQuA: Practical Backdoor Injection on Large Language Model Quantization," ACM Web Conference (WWW), 2026, pp. 2764–2775.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.