This is a Python implementation of the protocols presented in Quantum state preparation for multivariate functions. They are based on function approximations with finite Fourier or Chebyshev series, efficient block encodings of Fourier and Chebyshev basis functions, and the linear combination of unitaries (LCU).
To install the project, clone the repository and run:
python -m pip install --upgrade pip
python -m pip install uv
uv venv .venv -p 3.12
source .venv/bin/activate
uv pip install -r requirements.txt
uv pip install -e .
All circuits are implemented with TKET. The main code implementing the protocols is in mvsp/circuits/lcu_state_preparation
with the following files:
- lcu_state_preparation_block_encoding.py: circuits to implement the block encodings for Fourier and Chebyshev basis functions.
- lcu_state_preparation.py: given the basis coefficients as input, implements the circuit for multivariate state preparation (see Figs. 4 and 5 from the paper).
The circuit construction is based on two elements, the RegisterBox
and QRegs
. RegisterBox
contains the gates and operations and QRegs
is the quantum register that keeps track which qubits the gates act on. The code can be found in mvsp/circuits/core
and one can check the RegisterBox example notebook for further details.
The LCU state preparation example notebook describes how to use these circuit constructions for quantum state preparation.
In addition to the main code we also provide multiple primitives like qubitisation, select and prepare boxes, and measurement utility functions.
The repo contains all scripts and data for reproducing the figures in the paper. In addition we provide the code to generate the data making it straightforward to extend the results to other target functions. Moreover, we include as supplementary material the exact circuits that were run on the Quantinuum H2-1 device for Fig. 10 in the paper.
To reproduce Fig. 6 run
python scripts/plot_basis_functions.py
The code generates the block encodings for Fourier and Chebyshev basis functions using our protocols and plots them together with the numerical evaluation of the basis functions.
To reproduce Fig. 7 run
python scripts/plot_chebyshev_resources.py
The code uses the data stored in data/Chebyshev_ricker2d_resource_scaling
.
All data can be generated with the following 3 scripts.
-
scripts/max_errors.py: numerically computes the uniform error of the Chebyshev approximation on
$[-1,1]^2$ . Run with the following arguments to reproduce the figure. For more options, run with-h
.python scripts/max_errors.py -f ricker2d -t chebyshev -d `seq 63`
-
scripts/run_chebyshev_resources.sh: calls
scripts/compute_resources.py
for varying polynomial degress and numbers of qubits. This computes the two-qubit gate counts and other resources compiled for the Quantinuum H2-1 native gate set. Compilation details can be adjusted via command line arguments, see thepython scripts/compute_resources.py -h
for details. -
scripts/run_chebyshev_simulations.sh: works similarly but now also simulates the circuit outputs with the IBM Aer backend. This is separate from the previous script because the simulation takes longer so we generate the data for fewer degrees.
To reproduce Fig. 8 run
python scripts/plot_fourier_resources.py
The code uses the data stored in data/Fourier_cauchy2d_resource_scaling
.
The data generation is similar to the one described in section 2D Ricker wavelet via Chebyshev series (Fig. 7).
Numerically compute the uniform error of the Fourier approximation of the bivariate Student's t-distribution over
python scripts/max_errors.py -f cauchy2d -t fourier -d `seq 63`
The shell scripts for generating resources and simulation data are scripts/run_fourier_resources.sh
an scripts/run_fourier_simulations.sh
.
To reproduce Fig. 9 run
python mvsp/applications/chemistry/plotting/chemistry_plotting_script.py
This can take several hours due to the size of the simulated circuits.
The folder mvsp/applications/chemistry
provides the methods to reproduce the circuits for the chemistry experiments. A single particle plane wavefunction was constructed using the Fourier state preparation using a nuclear lattice hamiltonian. Various lattices are provided in mvsp/applications/chemistry/lattices/lattice.py
. We also provide a tutorial on how to construct plane wave circuit from a lattice Hamiltonian.
Supplementary data and plots are also provided in the folder data/electron_in_Coulomb_potential
and plots/electron_in_Coulomb_potential
.
To reproduce Fig. 10 run
python scripts/hardware_experiment_2d_gaussian_plot.py
The shot data from the hardware experiments are stored in data/hardware_experiment/shots_n9_c7_rho0.*.pkl
. Given this shot data, the data for Fig. 10 (density estimates etc.) can be generated with
python scripts/hardware_experiment_2d_gaussian.py
This can take several minutes to run.
To reproduce Fig. 11 in the appendix (kernel density estimate cross validation) run
python scripts/kde_cross_validation_plot.py
The data can be generated with
python scripts/kde_cross_validation.py
This can take several minutes to run.
The folder data/hardware_experiments/circuits
contains the circuits used for the hardware experiments performed on the H2-1 trapped-ion quantum computer. We have both the original and compiled circuits, along with iamges of the circuits. This supplementary data is not shown in the paper.
If you use this code in your work, please consider citing our corresponding research paper.
@misc{rosenkranzQuantumStatePreparation2024,
title = {Quantum State Preparation for Multivariate Functions},
author = {Rosenkranz, Matthias and Brunner, Eric and {Marin-Sanchez}, Gabriel and Fitzpatrick, Nathan and Dilkes, Silas and Tang, Yao and Kikuchi, Yuta and Benedetti, Marcello},
year = {2024},
number = {arXiv:2405.21058},
publisher = {arXiv},
eprint = {2405.21058},
archiveprefix = {arXiv},
primaryClass = {quant-ph}
}