Who can compete with quantum computers? Lecture notes on quantum inspired tensor networks computational techniques

Xavier Waintal; Chen-How Huang; Christoph W. Groth

Source-linked AI summary

Who can compete with quantum computers? Lecture notes on quantum inspired tensor networks computational techniques

Xavier Waintal, Chen-How Huang, Christoph W. Groth

arXiv:2601.03035v3Jan 6, 2026quant-phcond-mat.str-el

TL;DR

The lectures address how tensor-network methods can handle exponentially large vectors and matrices, including quantum-computing states and function representations. They develop MPS/MPO algorithms, TCI, and quantics calculus, showing that depth-D, N-qubit circuit families span O(DN) dimensions rather than the full 2^N-dimensional space.

Problem
The lectures examine how classical methods can represent and manipulate states and functions associated with exponentially large spaces, despite quantum states having dimension 2^N and practical hardware errors limiting circuit depth.
Method
They develop MPS/MPO algorithms for large-scale linear algebra, Tensor Cross Interpolation for mapping known functions into MPS, and quantics MPO constructions for differentiation and related operations.
Results
O(DN) is the total dimension spanned by depth-D, N-qubit circuits, substantially smaller than the full 2^N-dimensional Hilbert space.
Takeaways & Limitations
TCI provides a route for mapping problems into tensor-network form, supporting applications beyond many-body physics such as quantics-based partial differential equations.
Takeaways & Limitations
Current quantum hardware has ε around 10^-3, which strongly limits usable circuit depth and motivates quantum error correction.

Abstract

from arXiv · show

This is a set of lectures on tensor networks with a strong emphasis on the core algorithms involving Matrix Product States (MPS) and Matrix Product Operators (MPO). Compared to other presentations, particular care has been given to disentangle aspects of tensor networks from the quantum many-body problem: MPO/MPS algorithms are presented as a way to deal with linear algebra on extremely (exponentially) large matrices and vectors, regardless of any particular application. The lectures include well-known algorithms to find eigenvectors of MPOs (the celebrated DMRG), solve linear problems, and recent learning algorithms that allow one to map a known function into an MPS (the Tensor Cross Interpolation, or TCI, algorithm). The lectures end with a discussion of how to represent functions and perform calculus with tensor networks using the "quantics" representation. They include the detailed analytical construction of important MPOs such as those for differentiation, indefinite integration, convolution, and the quantum Fourier transform. Three concrete applications are discussed in detail: the simulation of a quantum computer (either exactly or with compression), the simulation of a quantum annealer, and techniques to solve partial differential equations (e.g. Poisson, diffusion, or Gross-Pitaevskii) within the "quantics" representation. The lectures have been designed to be accessible to a first-year PhD student and include detailed proofs of all statements.

1 Univ. Grenoble Alpes, CEA, IRIG-PHELIQS GT, F-38000 Grenoble, France

The supplied passages contain publication metadata but no substantive section content.

The section lists an institutional affiliation and publication-date placeholders.

1 Foreword

The lectures introduce tensor networks as classical techniques for exploring structured subspaces of exponentially large quantum states and emphasize practical algorithms, implementation, and scope boundaries.

Quantum states can be exponentially large, yet classical algorithms can calculate many of them by exploiting internal mathematical structure.
The lectures present tensor networks in quantum-computing contexts while separating their core linear-algebra techniques from many-body physics.
The blackboard lectures prioritize depth and code implementation, while excluding several advanced tensor-network families and techniques.
The manuscript also includes subjective views on quantum-computing claims and aims to guide readers toward information that may be missing from scientific articles.
The material covers MPS and MPO algorithms, including compression, DMRG, linear solves, and Tensor Cross Interpolation for mapping functions into tensor networks.
Quantics tensor trains extend these algorithms to functions and partial differential equations, including Fourier-transform operations represented through MPO-MPS products.

2 The quantum computer: a machine for performing certain matrix-vector multiplications

The section models a gate-based quantum computer as controlled linear algebra on exponentially large wavefunctions, while emphasizing output, circuit-depth, and hardware-fidelity constraints.

A gate-based quantum computer uses N qubits whose wavefunction contains 2^N complex amplitudes.
Quantum evolution applies one- and two-qubit unitary gates to the wavefunction, followed by probabilistic measurement of qubit values.
The model performs matrix-vector multiplications on exponentially large vectors but returns only N bits from a measurement sample rather than the full vector.
O(DN) is the dimension of the subspace spanned by depth-D circuits, far smaller than the full 2^N-dimensional Hilbert space.
For N = 100 and D = 10^6, the explorable subspace still has 20 orders of magnitude fewer degrees of freedom than the full Hilbert space.
Gate errors around ε ≈ 10^-3 limit practical circuit depth, while quantum error correction is presented as a possible remedy.

3 Tensor networks: basic notation and operations

Tensor networks represent high-order tensors as graphs of connected tensors, with contractions and index manipulations providing a scalable linear-algebra framework whose efficiency depends critically on contraction order.

Tensors generalize vectors and matrices to functions with arbitrary numbers of indexed dimensions.
Contraction identifies matching indices and sums over them, generalizing matrix-vector and matrix-matrix multiplication.
A tensor network is an undirected graph of tensors, and contracting it can range from easy to exponentially difficult.
The best contraction order is generally NP-complete to find, so tensor-network algorithms compare computational time and memory footprint when choosing strategies.
Horizontal stepwise contraction scales as D^4 in the example, whereas the unfavorable vertical order scales as D^5 and can become D^21 for an MPS with 20 tensors.
Fusing indices converts multi-legged tensors into matrices, enabling standard factorizations such as SVD, LU, and QR, with optional compression.

4 Basic quantum computer emulators

The lectures present several classical strategies for emulating quantum circuits as tensor-network contractions. Full-state simulation is simple but exponentially costly in qubit number, whereas exact MPS simulation trades this for depth-dependent bond growth and can exploit structured states.

Quantum-circuit emulation reduces to contracting the tensor network representing the circuit.Applying one- and two-qubit gates corresponds to tensor contractions whose result is the many-qubit wavefunction.
Full-state emulator: The full-state emulator stores 2^N complex amplitudes and has exponential memory, with runtime O(Ng2^N).The notes estimate 16 GB for 30 qubits and 16 TB for 40 qubits in double precision.
MPS exact emulator: Exact MPS simulation keeps one-qubit gates from increasing the bond rank and factorizes after neighboring two-qubit gates.The factorization can use QR or SVD; a two-qubit gate may increase χ by a factor of 2, or up to 4 for a general gate.
MPS exact emulator: MPS simulation is exponential in circuit depth but linear in the number of qubits, contrasting with state-vector simulation that is exponential in N.This advantage exploits the product-state structure of the initial quantum computer state.
General contraction strategies: Contraction order strongly affects computational cost, and heuristic graph-based ordering plus index slicing can distribute tensor-network work across CPUs or GPUs.A poor order can create intermediate objects of size d^N even when the final result is unchanged.

5 Compressing many-body states with matrix product states

Tensor-network simulation relies on low-rank compression, with SVD providing optimal truncations and entanglement determining when MPS representations remain efficient. Approximate circuit algorithms trade computational tractability against fidelity as bond dimensions constrain representable entanglement.

Approximate quantum-circuit simulation: Low-rank compression is the central approximation underlying tensor-network algorithms for simulating quantum computers.The approach is linked to entanglement and is applied after gates to keep states in MPS form.
Matrix compression: A rank-χ matrix can be compressed into two smaller matrices containing (P + Q − χ)χ numbers instead of PQ.Cross interpolation provides an exact construction for exactly low-rank matrices and an approximation for approximately low-rank ones.
Singular Value Decomposition: The truncated SVD gives the best rank-χ approximation by retaining the χ largest singular values.This theorem is central to tensor-network truncation and compression.
Entanglement and MPS: A bipartite quantum state is a product state exactly when its coefficient matrix has one nonzero singular value equal to 1.Singular values therefore connect matrix compression directly to quantum entanglement.
Entanglement and MPS: A rank-χ MPS has maximum entanglement entropy S = logχ, so it cannot exactly represent states with greater entanglement.For maximal entanglement, the entropy reaches logχ, while computing it requires SVD only of a χ × 2 × χ tensor rather than an exponentially large matrix.
Approximate quantum-circuit simulation: Repeated gate truncations typically make circuit fidelity decrease exponentially, with the error rate controlled by the bond dimension.The product of per-gate fidelities is reported as a good measure of overall fidelity in the random-circuit example.
DMRG for quantum circuits: Single-site DMRG cannot increase the tensor rank and may become trapped in local minima, motivating enrichment or two-site updates.Two-site DMRG fuses neighboring tensors, optimizes them, and uses truncated SVD to control the resulting rank.

6 The transverse field Ising model

The transverse field Ising model provides a tractable yet nontrivial testbed for tensor-network methods, spanning quantum dynamics, ground-state search, and optimization. Quantum annealing can nevertheless become exponentially slow when the minimum spectral gap shrinks exponentially with system size.

Model and tasks: The transverse field Ising model is defined for N spins and is used to study both ground states and dynamics from specified initial states.At hX = 0, it reduces to the classical Ising model.
Model tractability: Despite requiring a vector of size 2^N for brute-force diagonalization, the one-dimensional nearest-neighbor model maps to free fermions and can be solved exactly.For more complex one-dimensional or quasi-one-dimensional interactions, DMRG can converge to essentially the exact ground state.
Optimization motivation: Frustrated couplings make classical Ising ground-state search NP-complete and allow discrete optimization problems to be mapped onto Hamiltonian ground states.This motivates using qubit platforms and transverse-field Ising dynamics for optimization problems.
Quantum annealing: The annealing regime depends on whether the rate |dhX/dt| is small or large relative to the square of the minimum gap Δ.The relevant transition is identified as a Landau-Zener transition.
Quantum annealing: For interesting spin-glass Ising models, the minimum gap Δ tends to decrease exponentially with N, making quantum annealing exponentially long.This is presented as a limitation of the annealing process for such problems.

7 Solving Hamiltonian models

The section adapts tensor-network algorithms from quantum circuits to Hamiltonian models, constructing Hamiltonians as MPOs and using DMRG or TEBD to obtain ground states and dynamics. For the TFI model, imaginary-time TEBD converges quickly, with η≈0.1 balancing time-step and compression errors.

Hamiltonian algorithms: Hamiltonian problems can reuse quantum-circuit tensor-network algorithms by replacing unitary operators with Hermitian matrices.The same framework applies beyond many-body physics because MPO algorithms can diagonalize general MPOs.
Direct MPO construction: Explicit Hamiltonian construction as an MPO is generally nontrivial, but nearest-neighbor TFI couplings permit an analytical construction.Building the matrix explicitly and converting it would be exponentially costly, motivating direct construction.
Direct MPO construction: The auto-MPO construction stores intermediate operators in MPO columns and accumulates the Hamiltonian in the final column.More complex interactions require additional stored elements and therefore larger MPO rank; practical implementations may compress the MPO or use TCI.
DMRG: DMRG minimizes the energy over normalized MPS tensors by sweeping through sites and selecting the lowest eigenvector of each effective environment matrix.The local eigenproblem can use LAPACK or Krylov methods such as Lanczos, exploiting efficient environment-based matrix–vector products.
Quantum dynamics with TEBD: Imaginary-time TEBD applies a Trotter decomposition of e^-iHη and its imaginary-time version to evolve the TFI model toward its ground state.The method uses local longitudinal, transverse, and interaction terms; second-order Trotterization is preferable because the first-order formula has corrections.
Quantum dynamics with TEBD: η≈0.1 is optimal in the illustrated TFI calculation when both runtime and bond dimension are considered.Small η improves convergence conditions but increases compression-step accumulation, which can be offset by increasing bond dimension.

8 MPO and MPS as large matrices and vectors

MPS and MPO are presented as compressed representations of gigantic vectors and matrices, enabling a broad linear-algebra toolbox beyond many-body physics. The remaining challenge is constructing tensor networks from general data, addressed by TCI alongside operations such as multiplication, addition, compression, eigenvalue computation, and linear solves.

Tensor networks as linear algebra: MPS and MPO represent gigantic vectors and matrices, extending tensor-network methods to linear algebra outside many-body physics.Their usefulness depends on whether the relevant solutions possess exploitable low-rank structure.
Core operations: The toolbox includes direct MPS sampling, MPO–MPS and MPO–MPO multiplication, lowest-eigenvalue computation, and MPS or MPO compression.These operations form an almost complete toolkit for ultra-large matrices and vectors.
Data-driven construction: Constructing tensor networks for general data remains the main missing ingredient because circuit- and Hamiltonian-specific constructions do not generalize broadly.The lectures introduce tensor cross interpolation as the next solution to this problem.
MPS operations: Element-wise products of MPS can be formed with a copy tensor and then approximated using zip-up, DMRG sweeps, or TCI.The stated cost of these approximation algorithms scales as χ^4, while newer χ^3 approaches were not public at writing.
MPS operations: MPS addition is straightforward but produces a bond dimension equal to the sum of the individual bond dimensions before possible compression.If the summands are identical, the true bond dimension can remain unchanged after compression.
Linear problems: For positive-definite MPOs, solving Ax=b can be reduced to repeated small local linear problems by minimizing a convex functional tensor by tensor.Sweeps continue until convergence, using conventional linear algebra or Krylov techniques for each local update.
Linear problems: When A is not positive definite, the tensor-by-tensor approach has no convergence guarantee, although convergence still yields the correct solution.One remedy is transforming the problem to A†Ax=A†b, which is positive definite under suitable conditions.

9 Tensor Cross Interpolation for learning tensor networks

Tensor Cross Interpolation (TCI) learns an MPS or MPO representation from function evaluations, using cross interpolation to avoid accessing exponentially large tensors. Its selected pivots define compact representations that support downstream tensor-network algorithms and can accelerate oscillatory integration.

TCI overview: TCI maps a known function queried by indices into an approximate MPS or MPO representation.The input is a function returning tensor entries rather than the exponentially large tensor itself.
TCI overview: TCI is an active-learning algorithm that requests only a tiny fraction of possible configurations.It adaptively selects the data points used to construct the representation.
Cross interpolation: Cross interpolation approximates a low-rank matrix using only selected rows and columns, without accessing the full matrix.The approximation is nearly as good as SVD while requiring only a set of χ rows and columns.
Cross interpolation: The cross-interpolation approximation is exact on the construction blocks and exact for matrices of rank χ when the pivot block is χ × χ.Its error is represented by the corresponding Schur complement.
Tensor extension: TCI recursively flattens tensor indices and applies cross interpolation until the tensor is factorized.The naive construction exposes the pivot structure but is itself impractical for exponentially large matrices.
Applications: Only O(Ndχ^2) entries are used, far fewer than d^N, and the resulting representation unlocks MPO/MPS algorithms for new applications.The lectures identify integration as one application, where TCI can avoid Monte Carlo’s slow convergence and oscillatory sign problem.
Applications: A ten-dimensional oscillatory integral achieved around eight digits of precision with a few million integrand evaluations, a seven-orders-of-magnitude speed-up.The direct approach would require approximately 2^110 ≈ 1.6 × 10^13 calls in the cited example.

10 The Quantics representation of functions

The quantics representation encodes discretized functions in binary-index MPS form, associating tensor indices with exponentially separated spatial scales. Low-rank quantics structure enables function representation on extremely fine grids and supplies the basis for tensor-network PDE solvers.

10.2 Quantics for PDEs: The quantics PDE workflow discretizes fields, constructs differential operators as MPOs, converts inputs with TCI, and evolves or solves them using MPS/MPO algorithms.The Gross–Pitaevskii example requires quantics discretization, MPO differential operators, TCI-transformed inputs, and a choice of dynamical solver.
10.1 The basics of quantics: Quantics represents a discretized function Ψ_n as an MPS whose indices are the binary bits of n.Different bits correspond to different spatial scales, from unit changes to exponentially large increments.
10.1 The basics of quantics: Quantics efficiency depends on limited entanglement between scales, which evidence suggests occurs in many interesting problems.The representation is therefore useful when multiscale structure remains low-rank.
10.1 The basics of quantics: Exponentials have rank 1, trigonometric and hyperbolic elementary functions have rank 2, and sums of two cosines have rank 4 regardless of widely separated frequencies.These examples show why quantics can represent functions containing vastly different length scales.
10.1 The basics of quantics: Any polynomial of degree n can be represented exactly by an MPS of rank n + 1.Since smooth functions can be approximated by polynomials, smooth functions generally admit low-rank approximate quantics representations.

10.3 The magic quantics tensor

The magic quantics tensor encodes binary addition and carry propagation, enabling MPO constructions for translations, convolutions, and finite-difference operators. The same local-message strategy also represents comparisons and indefinite integration in quantics.

10.3 The magic quantics tensor: The magic quantics tensor captures binary addition constraints through local bits and carry variables.Its nonzero entries enforce the output bit and Euclidean-division carry at each stage.
10.3 The magic quantics tensor: Finite-difference derivatives and the discrete Laplacian are constructed from addition-based MPOs.The Laplacian is obtained by adding the two corresponding shifted MPOs with n = 0···001.
10.3 The magic quantics tensor: Connecting carries across sites constructs an MPO for binary addition, including modular addition when the boundary carry is modified.Tracing over an unneeded output produces a simpler addition-related MPO.
10.3 The magic quantics tensor: The addition MPO supports convolutions and translations of quantics functions.Convolutions combine two MPS, while translations are obtained by applying the MPO for a specified binary displacement.
10.4 Indefinite integral: Quantics makes indefinite integration as simple as differentiation, using an MPO of rank χ = 2.The construction represents the Heaviside function through bit-by-bit comparison with a message indicating whether the result is decided.
10.4 Indefinite integral: The comparison MPO processes significant bits first and propagates a decision flag once the ordering of the two integers is fixed.If the comparison remains undecided, later bits continue the comparison; otherwise the result is carried forward.

10.5 Generalization to higher dimensions

Higher-dimensional quantics representations require choosing an ordering of binary indices, with mirror ordering often producing the lowest bond dimension in two dimensions. The resulting MPO/MPS toolbox can solve PDEs, but efficiency depends on maintaining low-rank inputs and solutions.

10.5 Generalization to higher dimensions: Multidimensional quantics can order binary indices by variable, by scale through interleaving, or through a mirror configuration.The mirror arrangement combines features of the other orderings and has often yielded the lowest bond dimension in two dimensions.
10.5 Generalization to higher dimensions: Extending the mirror arrangement to three dimensions requires tree product states and tree product operators.The associated MPO/MPS algorithms can be extended to trees, but the literature is still emerging.
10.6 PDE applications: The Poisson solver selects an index ordering, converts the source density with TCI, constructs the Laplacian MPO, and applies a tensor-network linear solver.The workflow replaces dense vectors and matrices with their MPS and MPO counterparts.
10.6 PDE applications: When source and solution bond dimensions are small and independent of grid-bit depth, exponentially fine grids are reachable at polynomial cost.The unknown bond dimensions determine whether the method is advantageous.
10.6 PDE applications: Boundary conditions are more difficult to implement and may require adding a diagonal MPO derived from a density function.A large density models a perfect metal and enforces a Dirichlet condition in the described Helmholtz formulation.
10.6 PDE applications: Efficiency remains constrained by the rank of the represented geometry or density, since even simple shapes such as spheres may not have low rank.Finding low-rank quantics descriptions of geometries is identified as a difficult open problem.
10.6 PDE applications: The Schrödinger equation becomes an MPO eigenvalue problem solvable with DMRG once the potential is represented in MPO form.The potential can come from TCI or from a preceding Poisson solution.

10.8 The quantum Fourier transform as a low-rank MPO

The lectures construct the quantum Fourier transform as a low-rank MPO by exploiting smoothness after a suitable bit ordering. This representation supports quantics Fourier operations and a heat-equation solver built from TCI and MPO–MPS products.

Low-rank structure: The discrete Fourier transform is the quantum Fourier transform and has MPO rank around χ = 15 at machine precision, with χ = 10 typically sufficient in practice.Its low rank has consequences for entanglement generation in the corresponding quantum algorithm.
Low-rank structure: Reversing the time and frequency bit order is crucial because the QFT is not low rank in the unreversed ordering.The ordering keeps small time scales near their corresponding large frequencies.
Explicit construction: After splitting the bits, only the smooth factor e^(-i2πA) links the two groups, and polynomial approximation yields a sum of factorized terms.Because A lies in [0,1], the smooth factor can be approximated with exponential accuracy.
Explicit construction: The resulting decomposition is a sum of χ products, each involving one factor from the first bit group and one from the remaining qubits, proving the low-rank factorization.The explicit MPO construction uses interpolative polynomial ideas and Chebyshev grid points for rapid convergence.
Application to the heat equation: For the heat equation, quantics applies TCI to the initial condition and kernel, then uses Fourier transforms and MPO–MPS multiplication to obtain the solution.The workflow uses two TCI calls and three MPO–MPS multiplications; the lectures report near-instantaneous laptop calculations even for a billion-point grid.

11 Conclusion

The conclusion presents tensor networks as versatile tools for exponentially large problems while warning that they are not universally appropriate. It emphasizes broad applicability beyond many-body physics and identifies TCI as a possible bridge to new applications.

Conclusion: Tensor-network representations can support many purposes related and unrelated to quantum many-body problems, but other representations may succeed when tensor networks fail.The conclusion stresses that exponentially large problems require exploiting some structure, which need not be entanglement.
Scope: The MPO/MPS toolbox is presented independently from many-body physics, although additional problem structure can make specialized algorithms faster or more accurate.The traditional setting often identifies the MPS with a many-body ground state and the MPO with a Hamiltonian.
Outlook: TCI is highlighted as a promising, but explicitly uncertain, route for mapping non-many-body applications such as quantics PDEs onto tensor-network methods.The authors describe this emphasis as a bet rather than a certainty.

A Code repositories

Two code repositories accompany the lectures, providing pedagogical implementations and participant-contributed examples used to generate selected figures.

Repositories: The tutorial repository contains Python examples implementing elementary gates, full-state and MPS quantum-computer emulators, and MPS routines.The examples were prepared for the hands-on sessions.
Repositories: The example repository contains participant-contributed code generating data for the GHZ-state timing comparison and imaginary-time TEBD calculation.The listed outputs correspond to Figures 1 and 3.