arxiv: 2604.06270 · v1 · submitted 2026-04-07 · 🪐 quant-ph

Recognition: 2 theorem links

· Lean Theorem

Accelerating Quantum State Encoding with SIMD: Design, Implementation, and Benchmarking

Riza Alaudin Syah , Irwan Alnarus Kautsar , Gunawan Witjaksono , Haza Nuzly Bin Abdull Hamed

Authors on Pith no claims yet

Pith reviewed 2026-05-10 19:19 UTC · model grok-4.3

classification 🪐 quant-ph

keywords quantum simulationangle encodingSIMD optimizationRusthybrid quantum-classicalstate vectorperformance optimization

0 comments

The pith

A Rust SIMD kernel for angle encoding accelerates quantum simulators by 5.4% at 64 qubits on Apple Silicon.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

This paper presents Hybriqu Encoder, a specialized kernel designed to speed up the conversion of classical data into quantum states using angle encoding. In hybrid quantum-classical algorithms, encoding time often dominates, so faster encoding directly improves overall performance. The kernel leverages SIMD instructions to handle four rotations simultaneously, pre-computes trigonometric values, and optimizes for cache efficiency within a safe Rust wrapper accessible from Python. Benchmarks reveal a 5.4% speedup at 64 qubits, with larger benefits when data exceeds L1 cache, while memory-limited kernels show no gain from vectorization. These findings suggest that targeted architectural optimizations can reduce bottlenecks in scaling such systems.

Core claim

The paper claims that implementing angle encoding with SIMD vectorization in Rust, processing four double-precision rotations per operation using AVX lanes and pre-calculated factors, yields consistent performance improvements in quantum state encoding, demonstrated by a 5.4% speedup at 64 qubits on Apple Silicon where benefits increase with data size beyond cache limits and memory-bound approaches do not improve.

What carries the argument

Hybriqu Encoder: a SIMD-aware Rust kernel that vectorizes angle rotations to four doubles at a time, integrates with Python via CFFI, and manages cache-friendly data layout with pre-computed trig values.

If this is right

Vectorized angle encoding outperforms standard methods when computation dominates over memory access.
Performance advantages scale with larger data volumes that exceed small caches.
SIMD optimizations in safe languages like Rust can be integrated into quantum simulators without compromising safety.
Memory bandwidth constraints limit further acceleration for full state vector updates.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

Similar SIMD approaches could be applied to other encoding methods or qubit sizes to verify generalizability.
Combining this with multi-threading might yield multiplicative speedups in encoding phases.
Adoption in existing quantum frameworks could reduce runtime for data-intensive hybrid algorithms.

Load-bearing premise

The speedups are attributable to the SIMD vectorization and pre-calculated trigonometric factors rather than other implementation details or hardware specifics.

What would settle it

Running the same benchmark with a version of the kernel that disables SIMD but keeps all other optimizations would show zero or negative speedup if the vectorization is not the cause.

Figures

Figures reproduced from arXiv: 2604.06270 by Gunawan Witjaksono, Haza Nuzly Bin Abdull Hamed, Irwan Alnarus Kautsar, Riza Alaudin Syah.

**Figure 1.** Figure 1: Rust implementation demonstrating SIMD kernel functionality The same pattern is generated for SSE4.1 (128-bit) and AVX-512 (512-bit) lanes. Because each lane multiplies four (or eight) doubles at once, the inner loop’s trip count falls by the vector width, yielding a theoretical 4×/8× speed-up. For the cache-aware chunking, the encoder processes the input in groups of four features selected to match both A… view at source ↗

**Figure 2.** Figure 2: Proposed angle-encoded pseudocode The pseudocode constructs an angle-encoded vector θ of length nq, scaling each element of input vector x by 2π if within bounds, and filling the rest with zeros. Then, SIMDAngleEndcode8, :; = process_in_chunks x, :,4 Where chunks are processed as follows: For each chunk : # = R , S, S , STU (5) +VWXY = 2 ∙ # = R2 ∙ , 2 ∙ S, 2 ∙ S , 2 ∙ STU The … view at source ↗

**Figure 4.** Figure 4: SIMD angle-encoding algorithm By isolating the tunable parameter chunk_size, the proposed design remains portable across wider vector extensions e.g., setting chunk_size = 8 for AVX‑512 or 16 for SVE without altering the surrounding control structure. Consequently, the routine achieves high arithmetic intensity on current hardware while retaining forward compatibility, making it an effective building block… view at source ↗

**Figure 3.** Figure 3: Flowchart of SIMD angle encoding [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗

**Figure 5.** Figure 5: Benchmark results [PITH_FULL_IMAGE:figures/full_fig_p005_5.png] view at source ↗

read the original abstract

Efficient data encoding is the main factor affecting how fast hybrid quantum-classical algorithms run, but traditional simulators spend most of their time changing classical features into quantum rotations. This work introduces Hybriqu Encoder, a Rust-based, SIMD-aware kernel that focuses exclusively on angle encoding and integrates transparently with Python via CFFI. The kernel processes four double-precision rotations at once using AVX-class vector lanes, combines data in a way that fits well with the cache and uses pre-calculated trigonometric factors, while keeping all unsafe operations within a safe Rust interface. Benchmarks on Apple Silicon show that using pure angle encoding is 5.4% faster at 64 qubits, and the speedup increases as the amount of data exceeds the L1 cache size, while kernels that quickly apply rotations to the entire state vector are limited by memory and do not benefit from SIMD. These results indicate that using vectorization leads to consistent improvements when calculations are the main focus, but limits on data transfer speed prevent additional speed increases, highlighting the need for future efforts on better state updates and choosing between different processing methods. By combining smart optimization that considers the architecture with Rust's safety features, the Hybriqu Encoder offers a flexible base for bigger, mixed systems designed to reduce data encoding delays in future hybrid quantum-classical processes.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Desk Editor's Note private letter to a colleague

This is a practical engineering paper on a Rust SIMD kernel for angle encoding that reports a small 5.4% speedup at 64 qubits on Apple Silicon, but the performance claims lack the controls needed to attribute gains clearly.

read the letter

The main point is that the authors built and benchmarked a new Rust kernel called Hybriqu Encoder for angle encoding. It uses vector lanes to handle four double-precision rotations at once, precomputes trig factors, and arranges data for cache efficiency before exposing the result to Python through CFFI. On Apple Silicon the pure angle version runs 5.4% faster at 64 qubits, with the gap widening once data moves past L1 cache size. They correctly note that kernels dominated by full state-vector updates hit a memory wall and gain little from the same vectorization. That observation and the safe-Rust-plus-CFFI packaging are the useful parts of the work. The implementation choices look reasonable for a focused encoding step in hybrid quantum-classical pipelines. The soft spots sit in the evidence. The reported number comes without error bars, repetition counts, or an ablation that turns the SIMD lanes on and off while holding everything else fixed. There is also no comparison against a well-documented baseline or any check that the final state vectors match a reference implementation to machine precision. The mention of AVX-class instructions on ARM hardware needs clarification as well. These gaps make it hard to know how much of the 5.4% is truly from the vectorization and pre-calculation versus other unstated differences in loop structure or compiler settings. The paper is aimed at people who maintain quantum simulators or build hybrid algorithms and want a drop-in speed tweak for the encoding stage. A reader who already works at that level could test the code and see whether the gain appears in their own workload. It is incremental rather than foundational, yet the concrete implementation and timing data are specific enough that a serious referee could usefully review it and ask for the missing controls. I would send it to peer review.

Referee Report

4 major / 2 minor

Summary. The paper introduces Hybriqu Encoder, a Rust-based SIMD-aware kernel for angle encoding in quantum simulators. It processes four double-precision rotations using AVX-class vector lanes, cache-friendly data layouts, and pre-computed trigonometric factors, with transparent Python integration via CFFI. Benchmarks on Apple Silicon report that pure angle encoding is 5.4% faster at 64 qubits, with speedups increasing as data exceeds L1 cache size, while memory-bound kernels show no further SIMD benefit.

Significance. If the performance claims hold after proper validation, this work offers a practical, architecture-aware optimization for reducing data encoding overhead in hybrid quantum-classical algorithms. The modest but consistent gains underscore memory bandwidth limits in state-vector simulators and demonstrate the feasibility of safe SIMD implementations in Rust. A strength is the explicit focus on reproducible code and Python interoperability, which could aid adoption in existing quantum simulation workflows.

major comments (4)

[Benchmarking results] Benchmark results (abstract and benchmarking section): The reported 5.4% speedup at 64 qubits is presented without error bars, number of repetitions, statistical details, baseline code versions, or exact data sizes, preventing verification that the improvement exceeds measurement noise or implementation variance.
[Implementation and results sections] Implementation and results sections: No ablation study (e.g., SIMD enabled vs. disabled, or vs. a reference angle-encoding kernel) is provided to isolate the contribution of vectorization and pre-calculated trig factors from other unstated choices such as loop structure or memory layout.
[Numerical validation] Numerical validation (methods or results): The manuscript reports no fidelity, element-wise error, or accuracy metrics comparing Hybriqu Encoder state vectors to a standard reference implementation, leaving the claim of equivalent numerical output unverified.
[Hardware discussion] Hardware discussion (abstract and implementation): The description cites 'AVX-class' vector lanes on Apple Silicon, but AVX is an x86 ISA; the paper must specify the actual ARM vector instructions used (e.g., NEON) to support attribution of speedups to SIMD.

minor comments (2)

Clarify whether 'Hybriqu' is an acronym or proper name, and expand the abstract's reference to 'kernels that quickly apply rotations' with pseudocode or a methods subsection.
The abstract states that 'speedup increases as the amount of data exceeds the L1 cache size' – include a figure or table showing timing vs. qubit number or data size to make this trend quantitative.

Simulated Author's Rebuttal

4 responses · 0 unresolved

We thank the referee for their constructive and detailed review of our manuscript. We address each major comment point by point below and indicate the revisions we will make to improve the work's rigor and clarity.

read point-by-point responses

Referee: [Benchmarking results] Benchmark results (abstract and benchmarking section): The reported 5.4% speedup at 64 qubits is presented without error bars, number of repetitions, statistical details, baseline code versions, or exact data sizes, preventing verification that the improvement exceeds measurement noise or implementation variance.

Authors: We agree that the benchmarking presentation lacks sufficient statistical detail for independent verification. In the revised manuscript we will report the number of repetitions (50 independent runs per data point), include error bars as standard deviation, specify the exact baseline implementation versions (including Rust compiler flags and Python bindings), and list the precise state-vector sizes and memory footprints used at each qubit count. These additions will allow readers to assess whether the 5.4 % figure exceeds measurement variability. revision: yes
Referee: [Implementation and results sections] Implementation and results sections: No ablation study (e.g., SIMD enabled vs. disabled, or vs. a reference angle-encoding kernel) is provided to isolate the contribution of vectorization and pre-calculated trig factors from other unstated choices such as loop structure or memory layout.

Authors: We acknowledge that an ablation study would strengthen attribution of the observed gains. We will add a dedicated subsection in the results that compares (i) the full Hybriqu Encoder, (ii) the same kernel compiled with SIMD disabled (scalar fallback), and (iii) a version without pre-computed trigonometric tables, while holding loop structure and memory layout fixed. This will isolate the incremental benefit of vectorization and pre-calculation. revision: yes
Referee: [Numerical validation] Numerical validation (methods or results): The manuscript reports no fidelity, element-wise error, or accuracy metrics comparing Hybriqu Encoder state vectors to a standard reference implementation, leaving the claim of equivalent numerical output unverified.

Authors: We agree that explicit numerical validation is required. We will insert in the methods section a direct comparison of the final state vectors against a reference implementation (NumPy-based angle encoding), reporting both average fidelity and maximum absolute element-wise error across the benchmark suite. These metrics will confirm that the SIMD and pre-calculation optimizations preserve numerical equivalence within floating-point tolerance. revision: yes
Referee: [Hardware discussion] Hardware discussion (abstract and implementation): The description cites 'AVX-class' vector lanes on Apple Silicon, but AVX is an x86 ISA; the paper must specify the actual ARM vector instructions used (e.g., NEON) to support attribution of speedups to SIMD.

Authors: We thank the referee for catching this inaccuracy. The manuscript incorrectly uses the term 'AVX-class' for Apple Silicon, which implements ARM NEON (and optionally SVE) instructions. We will revise the abstract and implementation sections to state that four double-precision rotations are processed using ARM NEON vector lanes, with the observed speedups attributed to these ARM SIMD units together with the cache-friendly layout and pre-computed factors. revision: yes

Circularity Check

0 steps flagged

No circularity: purely implementational and empirical work with no derivations or self-referential predictions

full rationale

The paper describes the design and implementation of a Rust-based SIMD kernel (Hybriqu Encoder) for angle encoding in quantum simulators, followed by empirical benchmarks on Apple Silicon. No mathematical derivations, equations, fitted parameters, predictions, or uniqueness theorems appear in the abstract or described content. Claims rest on direct wall-clock timing measurements rather than any reduction by construction to prior inputs or self-citations. The work is self-contained against external benchmarks (standard angle encoding) with no load-bearing self-referential steps.

Axiom & Free-Parameter Ledger

0 free parameters · 2 axioms · 1 invented entities

The central performance claims rest on standard assumptions about SIMD hardware behavior and numerical stability of precomputed values rather than new physical axioms or fitted parameters.

axioms (2)

domain assumption AVX-class vector instructions are available and produce correct results for double-precision rotations on the target Apple Silicon hardware.
The kernel relies on processing four rotations per vector lane.
domain assumption Pre-calculated trigonometric factors introduce negligible numerical error compared with on-the-fly computation.
Used to avoid repeated trig calls while preserving encoding fidelity.

invented entities (1)

Hybriqu Encoder no independent evidence
purpose: A safe Rust kernel that applies AVX SIMD to angle encoding and exposes it to Python via CFFI.
The primary software artifact created by the authors.

pith-pipeline@v0.9.0 · 5551 in / 1400 out tokens · 65388 ms · 2026-05-10T19:19:29.115599+00:00 · methodology

discussion (0)

Lean theorems connected to this paper

Citations machine-checked in the Pith Canon. Every link opens the source theorem in the public Lean library.

IndisputableMonolith/Cost/FunctionalEquation.lean washburn_uniqueness_aczel unclear

?

unclear
Relation between the paper passage and the cited Recognition theorem.

The kernel processes four double-precision rotations at once using AVX-class vector lanes, combines data in a way that fits well with the cache and uses pre-calculated trigonometric factors

What do these tags mean?

matches: The paper's claim is directly supported by a theorem in the formal canon.
supports: The theorem supports part of the paper's argument, but the paper may add assumptions or extra steps.
extends: The paper goes beyond the formal theorem; the theorem is a base layer rather than the whole result.
uses: The paper appears to rely on the theorem as machinery.
contradicts: The paper's claim conflicts with a theorem or certificate in the canon.
unclear: Pith found a possible connection, but the passage is too broad, indirect, or ambiguous to say the theorem truly supports the claim.

Reference graph

Works this paper leans on

27 extracted references · 21 canonical work pages

[1]

Hybrid Quantu m Encoding: Combining Amplitude and Basis Encoding for Enhanced Data Storage and Processing in Quantum Computing,

B. Bhabhatsatam and S. Smanchat, “Hybrid Quantu m Encoding: Combining Amplitude and Basis Encoding for Enhanced Data Storage and Processing in Quantum Computing,” in 2023 20th International Joint Conference on Computer Science and Software Engineering (JCSSE) , June 2023, pp. 512–516. doi: 10.1109/JCSSE58229.2023.10201947

work page doi:10.1109/jcsse58229.2023.10201947 2023
[2]

Simple Quantum State Encodings for Hybrid Programming of Q uantum Simulators,

T. Gabor, M. Lingsch Rosenfeld, and C. Linnhoff -Popien, “Simple Quantum State Encodings for Hybrid Programming of Q uantum Simulators,” in 2022 IEEE 19th International Conference on Software Architecture Companion (ICSA-C) , Mar. 2022, pp. 170–

2022
[3]

doi: 10.1109/ICSA-C54293.2022.00040

work page doi:10.1109/icsa-c54293.2022.00040 2022
[4]

An implementation and analysis of a practical quantum link architecture utilizing entangled photon sources,

K.-C. Chen, X. Li, X. Xu, Y.-Y. Wang, and C.-Y. Liu, “Quantum- Classical-Quantum Workflow in Quantum-HPC Middlewar e with GPU Acceleration,” in 2024 International Conference on Quantum Communications, Networking, and Computing (QCNC) , July 2024, pp. 304–311. doi: 10.1109/QCNC62729.2024.00017

work page doi:10.1109/qcnc62729.2024.00017 2024
[5]

Implementing Post-quantum Cryptography for Develop ers,

J. Hekkala, M. Muurman, K. Halunen, and V. Vall ivaara, “Implementing Post-quantum Cryptography for Develop ers,” SN Comput. Sci. , vol. 4, no. 4, p. 365, Apr. 2023, doi: 10.1007/s4 2979- 023-01724-1

work page doi:10.1007/s4 2023
[6]

Quantum state preparation protocol for encoding classical data into the amplitudes of a quantum inf ormation processing register’s wave function,

S. Ashhab, “Quantum state preparation protocol for encoding classical data into the amplitudes of a quantum inf ormation processing register’s wave function,” Phys. Rev. Res. , vol. 4, no. 1, p. 013091, Feb. 2022, doi: 10.1103/PhysRevResearch.4.013091

work page doi:10.1103/physrevresearch.4.013091 2022
[7]

Solving the encoding bottleneck: of the HHL algorithm, by the HHL algorithm

G. P. He, “Solving the encoding bottleneck: of the HHL algorithm, by the HHL algorithm,” arXiv.org. Accessed: Apr. 23 , 2025. [Online]. Available: https://arxiv.org/abs/2502.13534v2

work page arXiv 2025
[8]

Luongo, Chapter 3 Classical data and quantum computers | Quantum algorithms for data analysis

A. Luongo, Chapter 3 Classical data and quantum computers | Quantum algorithms for data analysis . Accessed: Apr. 23, 2025. [Online]. Available: https://quantumalgorithms.org/ chap-classical- data-quantum-computers.html

2025
[9]

Quantum data encoding: a comparative analysis of classical-to-quantum mapping techniques and their impact on machine learning accuracy,

M. Rath and H. Date, “Quantum data encoding: a comparative analysis of classical-to-quantum mapping techniques and their impact on machine learning accuracy,” EPJ Quantum Technol. , vol. 11, no. 1, Art. no. 1, Dec. 2024, doi: 10.1140/epjqt/s40507-024-00285-3

work page doi:10.1140/epjqt/s40507-024-00285-3 2024
[10]

Hybrid quantum programming with PennyLane Lightning on HPC platforms,

A. Asadi et al. , “Hybrid quantum programming with PennyLane Lightning on HPC platforms,” Mar. 04, 2024, arXiv : arXiv:2403.02512. doi: 10.48550/arXiv.2403.02512

work page doi:10.48550/arxiv.2403.02512 2024
[11]

The Efficient Preparation of Normal Distributions in Quantum Regi sters,

A. G. Rattew, Y. Sun, P. Minssen, and M. Pisto ia, “The Efficient Preparation of Normal Distributions in Quantum Regi sters,” Quantum , vol. 5, p. 609, Dec. 2021, doi: 10.22331/q-2021-1 2-23- 609

work page doi:10.22331/q-2021-1 2021
[12]

PennyLane + AMD = \: Running Lightning in a hetero geneous world | PennyLane Blog

Lee O’Riordan, Vincent Michaud-Rioux, and Josh Izaac, “PennyLane + AMD = \: Running Lightning in a hetero geneous world | PennyLane Blog.” Accessed: Apr. 18, 2025. [ Online]. Available: https://pennylane.ai/blog/2024/03/scale_up_your_simulations_with_ amd_and_lightning

2025
[13]

qHiPSTER: The quantum high performance software testing environment,

M. Smelyanskiy, N. P. D. Sawaya, and A. Aspuru -Guzik, “qHiPSTER: The Quantum High Performance Software Te sting Environment,” May 12, 2016, arXiv : arXiv:1601.07195. doi: 10.48550/arXiv.1601.07195

work page doi:10.48550/arxiv.1601.07195 2016
[14]

and Mitarai, Kosuke and Imai, Ryosuke and Tamiya, Shiro and Yamamoto, Takahiro and Yan, Tennin and Kawakubo, Toru and Nakagawa, Yuya O

Y. Suzuki et al. , “Qulacs: a fast and versatile quantum circuit simulator for research purpose,” Quantum , vol. 5, p. 559, Oct. 2021, doi: 10.22331/q-2021-10-06-559

work page doi:10.22331/q-2021-10-06-559 2021
[15]

Q. A. team and collaborators, qsim . (Oct. 01, 2021). Zenodo. doi: 10.5281/zenodo.5544365

work page doi:10.5281/zenodo.5544365 2021
[16]

0.5 petabyte simu lation of a 45-qubit quantum circuit,

T. Häner and D. S. Steiger, “0.5 petabyte simu lation of a 45-qubit quantum circuit,” in Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis , in SC ’17. New York, NY, USA: Association for Computin g Machinery, Nov. 2017, pp. 1–10. doi: 10.1145/3126908.3126947

work page doi:10.1145/3126908.3126947 2017
[17]

QuEST and High Performance Simulation of Quantum Computers,

T. Jones, A. Brown, I. Bush, and S. C. Benjamin, “QuEST and High Performance Simulation of Quantum Computers,” Sci. Rep. , vol. 9, no. 1, p. 10736, July 2019, doi: 10.1038/s41598-019-47174-9

work page doi:10.1038/s41598-019-47174-9 2019
[18]

Schuld and F

M. Schuld and F. Petruccione, Machine Learning with Quantum Computers . in Quantum Science and Technology. Cham: Springer International Publishing, 2021. doi: 10.1007/978-3-030-83098-4

work page doi:10.1007/978-3-030-83098-4 2021
[19]

The rust language,

N. D. Matsakis and F. S. Klock, “The rust language,” Ada Lett , vol. 34, no. 3, pp. 103–104, Oct. 2014, doi: 10.1145/2692956.2663188

work page doi:10.1145/2692956.2663188 2014
[20]

RustBelt: securing the foundations of the Rust programming la nguage,

R. Jung, J.-H. Jourdan, R. Krebbers, and D. Dr eyer, “RustBelt: securing the foundations of the Rust programming la nguage,” Proc ACM Program Lang , vol. 2, no. POPL, p. 66:1-66:34, Dec. 2017, doi: 10.1145/3158154

work page doi:10.1145/3158154 2017
[21]

J. L. Hennessy and D. A. Patterson, Computer Architecture, Sixth Edition: A Quantitative Approach , 6th ed. San Francisco, CA, USA: Morgan Kaufmann Publishers Inc., 2017

2017
[22]

Software optimization resources. C ++ and assembly. Windows, Linux, BSD, Mac OS X

Agner Fog, “Software optimization resources. C ++ and assembly. Windows, Linux, BSD, Mac OS X.” Accessed: Apr. 14, 2025. [Online]. Available: https://www.agner.org/optimize/

2025
[23]

Jim Blandy, Jason Orendorff, and Leonora F. S. Tindall, Programming Rust: Fast, Safe Systems Development , 2nd ed. O’Reilly Media, 2017. Accessed: Apr. 14, 2025. [Online]. Available: https://www.amazon.com/Programming-Rust-Fast-Systems- Development/dp/1492052590

work page arXiv 2017
[24]

Faster 64-bit universal hashing using carry- less multiplications,

D. Lemire and O. Kaser, “Faster 64-bit universal hashing using carry- less multiplications,” J. Cryptogr. Eng. , vol. 6, no. 3, pp. 171–185, Sept. 2016, doi: 10.1007/s13389-015-0110-5

work page doi:10.1007/s13389-015-0110-5 2016
[25]

SV-sim: scalable PGAS-based state vector simulat ion of quantum circuits,

A. Li et al. , “SV-sim: scalable PGAS-based state vector simulat ion of quantum circuits,” in Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis , in SC ’21. New York, NY, USA: Association for Computing Machinery, Nov. 2021, pp. 1–14. doi: 10.1145/3458817.3476169

work page doi:10.1145/3458817.3476169 2021
[26]

Variational Quantum Algorithms,

M. Cerezo et al. , “Variational Quantum Algorithms,” Nat. Rev. Phys. , vol. 3, no. 9, pp. 625–644, Aug. 2021, doi: 10.1038 /s42254-021- 00348-9

2021
[27]

Supervised Learning with Quantum-Enhanced Feature Spaces

V. Havlíček et al. , “Supervised learning with quantum-enhanced feature spaces,” Nature , vol. 567, no. 7747, pp. 209–212, Mar. 2019, doi: 10.1038/s41586-019-0980-2

work page doi:10.1038/s41586-019-0980-2 2019