{"id":"17c31dee-39b2-4675-b4d2-81b2329525de","arxiv_id":"2502.01146","paper_version":1,"verdict":"UNVERDICTED","confidence":"HIGH","novelty_score":2.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"A structured tutorial that introduces quantum machine learning concepts, algorithms, theory, and PennyLane code to classical ML practitioners.","lead":"This tutorial teaches machine learning researchers the foundations of quantum machine learning, from quantum circuits to quantum kernels, networks, and transformers. It is a broad educational survey, not a new research result, and is useful for anyone mapping the QML landscape.","discovery_kind":"review","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The tutorial's hands-on claim depends on code examples that do not run as printed; the block-encoding demo in §2.5.2 prints an undefined variable `output_matrix`.","rationale":"The reader's weakest assumption is exactly the load-bearing concern: the code examples are central to the tutorial's stated purpose, and §2.5.2 contains an undefined variable that prevents the example from running. My review confirms this by locating the specific line and clarifying why it breaks the hands-on claim. I also found a secondary mathematical inconsistency in Example 3.8, but it does not change the verdict: the paper remains a tutorial rather than a research preprint, and the existing UNVERDICTED classification already reflects that. The concern reinforces moderate correctness risk and supports the reader's assessment without requiring a different verdict. I agree with the reader's identification, and I recommend no change to the verdict.","tokens_in":54714,"tokens_out":3517,"duration_ms":41045,"concrete_test":"Run every printed code block verbatim in a fresh environment using the PennyLane version pinned by the companion site. If §2.5.2 raises `NameError: name 'output_matrix' is not defined`, or if §2.5.1's `qml.device(\"default.qubit\", range(3))` fails, the tutorial as printed is not reproducible. Also compute `RX(pi/2)|0>` symbolically: if the amplitudes are not `cos(pi/4)` and `-i sin(pi/4)`, then Eq. (3.25) is wrong as written.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central claim is educational: a reader with a classical ML background should be able to understand and implement core QML models through this tutorial, including the code demonstrations. That claim requires the printed code to be runnable and the mathematical examples to be consistent. Section 2.5.2 violates this: after constructing the LCU block-encoding circuit, the code executes `print(np.real(np.round(output_matrix, 2)))`, but `output_matrix` is never defined or computed anywhere in the snippet. The example therefore cannot run as printed and does not demonstrate the block-encoding construction it claims to illustrate. A second, though smaller, issue appears in §2.5.1, where `qml.device(\"default.qubit\", range(3))` passes `range(3)` as a positional argument; current PennyLane expects a `wires` keyword argument or an integer, so this may also fail in standard environments. There is also a mathematical inconsistency in Example 3.8: starting from `RX(x) = e^{-ix\\sigma_x/2}`, Eq. (3.25) expands the state as `cos(x)|0> - i sin(x)|1>`, but the correct expansion is `cos(x/2)|0> - i sin(x/2)|1>`. The final kernel formula is correct, but a foundational example with wrong intermediate algebra undermines the tutorial's goal of building reliable understanding. These issues together mean the hands-on and self-consistency promises are not met by the submitted manuscript text, even if the companion website contains corrected notebooks.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"This manuscript presents a comprehensive tutorial on quantum machine learning (QML) aimed at readers with a classical machine-learning background. It covers foundational quantum computing concepts, quantum kernel methods, quantum neural networks, and quantum transformers, mixing formal definitions, theorem statements with proof sketches, and PennyLane code demonstrations. The stated goal is to enable hands-on learning and to bridge the gap between classical ML and QML, with a companion website hosting Jupyter notebooks.","tokens_in":1323,"tokens_out":1931,"duration_ms":81150,"significance":"If the presentation is corrected, this tutorial could serve as a valuable entry point for the QML community, particularly because it covers recent topics such as quantum transformers, trainability, and generalization, and because it attempts to connect classical and quantum formulations chapter by chapter. The inclusion of code demonstrations and a companion website is a useful pedagogical complement. However, the manuscript's value depends critically on the correctness of its mathematical exposition and the runnability of its code; several errors in both categories currently compromise the tutorial's central promise of hands-on, self-consistent learning.","major_comments":[{"comment":"The POVM measurement probability is stated as Pr(i) = |<psi|E_i|psi>|^2. For a POVM element E_i, the Born rule gives Pr(i) = <psi|E_i|psi> (equivalently Tr(rho E_i) for a density matrix). The square is incorrect and will mislead readers about generalized measurements. This is a fundamental concept in the tutorial's measurement section and must be fixed.","section":"§2.2.2, Eq. (2.42)"},{"comment":"The expansion of RX(x)|0> = exp(-i x sigma_x / 2)|0> is written as cos(x)|0> - i sin(x)|1>. The correct expansion is cos(x/2)|0> - i sin(x/2)|1>. The final kernel formula in Example 3.8, cos^2((x-x')/2), is consistent with the correct expansion, indicating a typographical slip, but this is exactly the kind of error that undermines a tutorial. The same half-angle omission appears in Example 3.11, Eq. (3.32), where the kernel is given as product_i cos^2(x_i - x'_i) rather than product_i cos^2((x_i - x'_i)/2).","section":"§3.2.2, Example 3.8, Eq. (3.25); §3.2.4, Example 3.11, Eq. (3.32)"},{"comment":"The block-encoding code ends with print(np.real(np.round(output_matrix, 2))), but output_matrix is never defined or computed in the snippet. The example therefore cannot run as printed, directly violating the tutorial's hands-on promise. The authors should either define output_matrix, for instance by reconstructing the block-encoded matrix from the circuit state, or remove the print statement.","section":"§2.5.2"},{"comment":"The proof relies on Algorithm 1 and Lemma 3.15, both of which assume input vectors with unit ell_1 norm (||r||_1 = 1). The Mercer feature map Phi_m obtained in the proof is normalized in the ell_2 norm only (assumed that ||Phi_m(x)|| = 1 for all x), and no argument is supplied for converting an ell_2-unit vector into an ell_1-unit vector while preserving the inner-product identity. As written, the universality proof is incomplete. The authors should clarify this step or provide a modified embedding that maps ell_2-unit vectors into ell_1-unit vectors.","section":"§3.3.1, proof of Theorem 3.13"}],"minor_comments":[{"comment":"The basis-encoding example calls qml.device(\"default.qubit\", range(3)), passing wires as a positional argument; use wires=range(3) for consistency with the rest of the tutorial and with current PennyLane APIs.","section":"§2.5.1"},{"comment":"There are several typographical errors, including seperable in Definition 2.2, Angel encoding in Table 3.2, and matrics in a remark in §2.3.2; a careful proofread is recommended.","section":"Throughout"},{"comment":"The angle-encoding expression writes R_sigma(x_i)|0>^{⊗N} inside the tensor product; the state notation should be indexed per qubit, for instance |0>_i, to avoid confusion about the tensor product structure.","section":"§2.3.1, Eq. (2.47)"},{"comment":"The derivation of the kernel estimation via U(x')U(x)^dagger includes an intermediate factor <0^{⊗N}|U(x')U(x)^dagger|0>^{⊗N}<0^{⊗N}|U(x')U(x)^dagger|0>^{⊗N}, which is a slightly abusive but understandable notation; consider clarifying the projector |0><0|^{⊗N} for readability.","section":"§3.4, Eq. (3.68)"}],"recommendation":"major_revision","confidential_remarks":"This is a book-length tutorial rather than a conventional research article; the editor may wish to confirm that such a contribution fits the journal's scope. The companion website is essential to the hands-on promise, but the printed code should be self-contained and runnable as published. I did not find evidence of deliberate circularity; the self-citations appear to be peripheral to the tutorial's main content."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"First thing you should know: this is a tutorial, not a research preprint. It does not claim new theorems or experiments. Its value is educational, and on that axis it is mostly good: the structure is sensible (classical foundation first, then quantum kernel, QNN, transformer chapters), the selection of topics is current, and the code demos cover the right ground. If you are an ML researcher wanting a map of QML, you could do much worse.\n\nWhat it does well: the exposition is generally careful, with proofs for central results and references for the rest. The chapter on quantum kernels properly explains the geometry test from Huang et al. and gives a concrete dataset construction. The quantum transformer chapter includes runtime analysis and numerical evidence, which is a nice touch. The self-citations are present but not load-bearing; the content is backed by the broader literature.\n\nWhere it is soft: the hands-on claim. Section 2.5.2 prints `output_matrix` but never defines it, so the block-encoding demo cannot run as printed. That is a direct hit on the stated goal. There are also two math slips: Eq. (2.42) gives the POVM probability with a square, but it should be `Tr(ρ E_i)` (or `<ψ|E_i|ψ>`), and Example 3.8 expands `RX(x)` as `cos(x)|0> - i sin(x)|1>` instead of using `x/2`. The final kernel in that example is correct, so it is an intermediate algebra error, not a wrong result, but in a tutorial that is exactly where it hurts. The `qml.device(\"default.qubit\", range(3))` call may also break in current PennyLane.\n\nThese are all fixable. The core mathematical and conceptual content is sound, and I did not find a load-bearing flaw beyond the broken code. For a tutorial, though, the errors are proportionally serious because the entire pitch is 'you can implement this.'\n\nBottom line: this is for ML practitioners and students who want an overview of QML with code. It is a legitimate teaching manuscript, but it needs a careful revision pass, checked by actually running the notebooks. I would send it to review for a teaching or survey venue, but not to a research journal. If the authors fix the code and the two equations, it would be a useful resource.\n\nMy recommendation: engage with it as a revise-and-resubmit at an appropriate venue; the errors are real but localized.","headline":"A useful, well-structured QML tutorial that needs a fix-it pass before it can deliver the hands-on promise.","tokens_in":55579,"tokens_out":2287,"would_cite":false,"duration_ms":23552,"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":"This tutorial claims that a reader with a classical machine-learning background can learn to implement quantum kernels, quantum neural networks, and quantum transformers—and to judge when they could beat classical models.","keywords":["quantum machine learning","quantum kernel methods","quantum neural networks","quantum transformers","block encoding","quantum singular value transformation","trainability","generalization"],"falsifier":"Run every code listing in Chapters 2 through 5 exactly as printed; a NameError on `output_matrix` in Section 2.5.2 already shows one example fails, and if further listings fail the tutorial does not deliver hands-on learning. At the science level, if no dataset satisfies the paper's own criterion for potential advantage ($s_Q \\ll n$ while $s_C \\propto n$ and $g_{CQ} \\sim \\sqrt{n}$), the claimed scope for quantum prediction advantage would lack an instance.","tokens_in":54542,"feed_emoji":"⚛️","tokens_out":6588,"duration_ms":63986,"temperature":0.7,"pith_summary":"This tutorial argues that a reader coming from classical machine learning can, without prior quantum training, understand and implement the core models of quantum machine learning. The authors build this bridge by treating three model families—quantum kernel methods, quantum neural networks, and quantum transformers—each time starting from the classical version, giving the quantum construction, analyzing expressivity, trainability, and generalization, and ending with runnable code. The central premise is that quantum circuits can serve both as feature maps for kernels and as trainable models for QNNs, and that these quantum implementations may carry computational advantages over classical ones on specified tasks. If the tutorial works as intended, it supplies the AI community with a practical on-ramp to quantum computing while classical model scaling is hitting cost and physical limits.","feed_headline":"One tutorial maps the route from classical ML to quantum advantage","feed_subtitle":"Hands-on code and theory for quantum kernels, quantum neural networks, and quantum transformers—built from a classical ML starting point.","key_machinery":"The workhorse is a data-dependent quantum circuit $U(x)$: it either acts as a feature map whose overlap $|\\langle\\phi(x)|\\phi(x')\\rangle|^2$ defines the quantum kernel, or as a parameterized ansatz whose measurement outcomes define a quantum neural network. For fault-tolerant algorithms, the tutorial relies on block encoding—placing a non-unitary matrix $A$ in the top-left corner of a larger unitary so that quantum singular value transformation (QSVT) can apply polynomial functions to singular values—as the unifying linear-algebra primitive. A named identity that does much of the theoretical work is the Fourier representation of angle-encoded quantum kernels, $k_Q(x,x') = \\sum_{s,t\\in\\Omega} c_{st} e^{isx}e^{itx'}$, which shows how classical kernel structure emerges from the eigenvalue spectrum of the encoding gates.","core_discovery":"The paper's central claim is that quantum machine learning—learning algorithms executed on quantum computers with potential advantages over classical implementations—can be presented from a classical ML foundation with theory and code together. Concretely, it claims that quantum kernels arise by encoding data into quantum states and evaluating their overlaps, that quantum neural networks are parameterized quantum circuits trained by classical optimizers, and that fault-tolerant quantum transformers can be built from quantum linear algebra, notably block encoding and quantum singular value transformation. It further asserts that the learnability of these models can be assessed along three axes—expressivity, trainability, and generalization—and that for quantum kernels a geometric criterion can indicate when a quantum kernel might beat all efficiently evaluable classical kernels. The tutorial's own framing is that it bridges 'it from bit' to 'it from qubit'.","pith_inferences":["An implied next step, not pursued in the paper, is to apply the same classical-foundation to quantum-construction to theory to code template to other model families, such as diffusion models, graph neural networks, or recommender systems.","A reader could test the tutorial's completeness by executing every printed code block against a pinned software environment; the undefined variable in Section 2.5.2 suggests the companion notebooks, not the printed snippets, are the reliable deliverable.","The geometric-difference test could be run on larger real-world datasets to see whether the predicted separation between quantum and classical kernels actually materializes, rather than only on adversarially constructed labels.","If hardware continues to scale per the quoted roadmaps, the tutorial's NISQ-to-FTQC progression suggests that quantum kernels trained today could be 'upgraded' to fault-tolerant variants using the same block-encoding toolbox."],"forward_implications":["A practitioner who finishes the tutorial should be able to implement a quantum kernel classifier on a reduced MNIST task and compare it to a classical SVM baseline.","The tutorial's theoretical sections turn the vague idea of quantum advantage into checkable criteria: compute $s_K(y) = y^{\\top}K^{-1}y$ and the geometric difference $g_{CQ}$ to test whether a quantum kernel could beat classical kernels.","In the fault-tolerant setting, block encoding plus QSVT gives a concrete blueprint for quantum transformers, with the tutorial reporting quadratic speedups in runtime analysis.","Read-in and read-out bottlenecks are identified as the main caveat: exponential runtime speedups can be erased by the cost of loading classical data or extracting outputs, so advantage claims must count those costs."],"supporting_citations":[{"why":"Supplies the textbook foundation for qubits, circuits, unitaries, and the universality of the circuit model, which the tutorial builds on throughout.","marker":"Nielsen and Chuang, 2011"},{"why":"The HHL quantum linear-systems solver that motivates fault-tolerant QML and defines the poly-logarithmic runtime benchmark for later algorithms.","marker":"Harrow et al., 2009"},{"why":"Defines block encoding and QSVT, the quantum linear-algebra machinery the tutorial uses for matrix inversion and quantum transformers.","marker":"Gilyén et al., 2019"},{"why":"Demonstrates quantum kernel methods and QNNs on a 5-qubit NISQ device, serving as the pivotal near-term demonstration the tutorial's Chapters 3 and 4 build around.","marker":"Havlíček et al., 2019"},{"why":"Introduces the generalization bound and asymmetric geometric difference the tutorial uses to judge potential quantum prediction advantage.","marker":"Huang et al., 2021a"},{"why":"Identifies read-in and read-out bottlenecks that the tutorial flags as a possible cancellation of claimed quantum speedups.","marker":"Aaronson, 2015"}],"fun_headline_variants":["Quantum ML for classical minds: kernels, circuits, and transformers","One tutorial from classical ML to quantum algorithm design","Classical ML to quantum ML: one hands-on roadmap","From bit to qubit: quantum ML tutorial for classical experts","Quantum kernels, QNNs, and transformers: a classical ML guide"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The tutorial's hands-on promise rests on the companion notebooks and printed code being complete and runnable; as published, the block-encoding example in Section 2.5.2 prints an undefined variable, so a reader following the text verbatim cannot execute it.","fun_headline_variants_meta":{"raw":{"variants":["Quantum ML for classical minds: kernels, circuits, and transformers","One tutorial from classical ML to quantum algorithm design","Classical ML to quantum ML: one hands-on roadmap","From bit to qubit: quantum ML tutorial for classical experts","Quantum kernels, QNNs, and transformers: a classical ML guide"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.001304,"raw_usage":{"total_tokens":5267,"prompt_tokens":843,"completion_tokens":4424,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":459,"completion_tokens_details":{"reasoning_tokens":4340}},"tokens_in":459,"tokens_out":4424,"duration_ms":28781,"temperature":1.0,"reasoning_tokens":4340,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-09T16:25:38.561689+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run every code listing in Chapters 2 through 5 exactly as printed; a NameError on `output_matrix` in Section 2.5.2 already shows one example fails, and if further listings fail the tutorial does not deliver hands-on learning. At the science level, if no dataset satisfies the paper's own criterion for potential advantage ($s_Q \\ll n$ while $s_C \\propto n$ and $g_{CQ} \\sim \\sqrt{n}$), the claimed scope for quantum prediction advantage would lack an instance.","supporting_citations":[],"review_version":1}