diff --git a/_build/.doctrees/channel.doctree b/_build/.doctrees/channel.doctree index 4d30112..5fd4c12 100644 Binary files a/_build/.doctrees/channel.doctree and b/_build/.doctrees/channel.doctree differ diff --git a/_build/.doctrees/environment.pickle b/_build/.doctrees/environment.pickle index b1a7221..e12f0bd 100644 Binary files a/_build/.doctrees/environment.pickle and b/_build/.doctrees/environment.pickle differ diff --git a/_build/.doctrees/error.doctree b/_build/.doctrees/error.doctree new file mode 100644 index 0000000..6fec1b5 Binary files /dev/null and b/_build/.doctrees/error.doctree differ diff --git a/_build/.doctrees/hamiltonian.doctree b/_build/.doctrees/hamiltonian.doctree index 891028d..943114f 100644 Binary files a/_build/.doctrees/hamiltonian.doctree and b/_build/.doctrees/hamiltonian.doctree differ diff --git a/_build/.doctrees/interference.doctree b/_build/.doctrees/interference.doctree index 25e4241..637e023 100644 Binary files a/_build/.doctrees/interference.doctree and b/_build/.doctrees/interference.doctree differ diff --git a/_build/.doctrees/intro.doctree b/_build/.doctrees/intro.doctree index e62a932..db914c2 100644 Binary files a/_build/.doctrees/intro.doctree and b/_build/.doctrees/intro.doctree differ diff --git a/_build/.doctrees/ordering.doctree b/_build/.doctrees/ordering.doctree index 6e7885d..ad9942a 100644 Binary files a/_build/.doctrees/ordering.doctree and b/_build/.doctrees/ordering.doctree differ diff --git a/_build/.doctrees/path_integral.doctree b/_build/.doctrees/path_integral.doctree index 427112a..c92c076 100644 Binary files a/_build/.doctrees/path_integral.doctree and b/_build/.doctrees/path_integral.doctree differ diff --git a/_build/.doctrees/simulation.doctree b/_build/.doctrees/simulation.doctree index d2e257e..1a28b4f 100644 Binary files a/_build/.doctrees/simulation.doctree and b/_build/.doctrees/simulation.doctree differ diff --git a/_build/.doctrees/spin.doctree b/_build/.doctrees/spin.doctree index 534f4e1..4a200ff 100644 Binary files a/_build/.doctrees/spin.doctree and b/_build/.doctrees/spin.doctree differ diff --git a/_build/.doctrees/trotter.doctree b/_build/.doctrees/trotter.doctree index c46e5ce..e1e7eb0 100644 Binary files a/_build/.doctrees/trotter.doctree and b/_build/.doctrees/trotter.doctree differ diff --git a/_build/.jupyter_cache/executed/41b70a05d966640cf0f603f7a1e78236/base.ipynb b/_build/.jupyter_cache/executed/41b70a05d966640cf0f603f7a1e78236/base.ipynb new file mode 100644 index 0000000..b485fa4 --- /dev/null +++ b/_build/.jupyter_cache/executed/41b70a05d966640cf0f603f7a1e78236/base.ipynb @@ -0,0 +1,566 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "5482b331", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit import QuantumCircuit\n", + "from qiskit_aer import AerSimulator\n", + "from qiskit.quantum_info import Kraus, SuperOp, random_quantum_channel, PTM, Choi, Chi\n", + "from qiskit.visualization import plot_histogram\n", + "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n", + "\n", + "# Import from Qiskit Aer noise module\n", + "from qiskit_aer.noise import (\n", + " NoiseModel,\n", + " QuantumError,\n", + " ReadoutError,\n", + " depolarizing_error,\n", + " pauli_error,\n", + " thermal_relaxation_error,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9eadfea1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "num_qubits: 1\n" + ] + }, + { + "data": { + "text/plain": [ + "PTM([[ 1.00000000e+00-1.62043135e-18j, -6.93889390e-18+3.46944695e-18j,\n", + " 3.12250226e-17+0.00000000e+00j, 0.00000000e+00-8.89628970e-18j],\n", + " [ 1.88065483e-01-5.20417043e-18j, -1.15362942e-01+0.00000000e+00j,\n", + " 1.53380269e-01+0.00000000e+00j, -2.06477978e-01+5.20417043e-18j],\n", + " [-1.25508465e-01+0.00000000e+00j, -4.57155516e-01+0.00000000e+00j,\n", + " -4.50234153e-01+0.00000000e+00j, -1.37733808e-01+0.00000000e+00j],\n", + " [ 1.09459698e-01+5.72149298e-18j, -6.41517365e-02+0.00000000e+00j,\n", + " -1.15933560e-01+0.00000000e+00j, 1.89603009e-01+1.18999014e-19j]],\n", + " input_dims=(2,), output_dims=(2,))" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rqc = PTM(random_quantum_channel(2, 2))\n", + "print('num_qubits: ', rqc.num_qubits)\n", + "rqc" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d5e0cce4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "PTM([[ 1.00000000e+00-3.56216466e-18j, -2.04130940e-17+3.63991378e-18j,\n", + " 1.61021616e-17+1.56352324e-18j, -2.86801248e-18-1.12994174e-17j],\n", + " [ 1.24518157e-01-5.52026460e-18j, -4.35641068e-02+3.18626648e-19j,\n", + " -6.28137076e-02-6.03338005e-19j, -3.64545873e-02-1.31129774e-18j],\n", + " [-1.70051742e-01+1.79445005e-18j, 2.67401695e-01-4.35444962e-19j,\n", + " 1.48560127e-01+0.00000000e+00j, 1.30290266e-01-1.27894574e-18j],\n", + " [ 1.32699502e-01+6.97581550e-18j, 4.82370373e-02+3.72130623e-19j,\n", + " 2.03762858e-02-1.37959793e-20j, 6.51631925e-02-1.26251661e-18j]],\n", + " input_dims=(2,), output_dims=(2,))" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rqc.compose(rqc)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a656e232", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rqc.power(4)\n", + "rqc.adjoint()\n", + "rqc.is_unitary()\n", + "rqc.is_cptp() # cp, tp, unitary" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a8692063", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Kraus([[[ 0.16510025+0.12138173j, -0.38686969+0.10334354j],\n", + " [ 0.18967791+0.08547223j, -0.24605432+0.14991361j]],\n", + "\n", + " [[-0.09578052+0.26031781j, 0.56404581+0.18198139j],\n", + " [ 0.18858765+0.45824502j, 0.18618338+0.23237352j]],\n", + "\n", + " [[ 0.26550027+0.11849789j, 0.03895017+0.30938416j],\n", + " [ 0.13478559-0.24814475j, -0.24065174-0.19046563j]],\n", + "\n", + " [[-0.50043097-0.34562591j, 0.1331936 -0.08831569j],\n", + " [-0.19262152+0.14479469j, 0.22561661-0.22099635j]]],\n", + " input_dims=(2,), output_dims=(2,))" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.quantum_info import Kraus\n", + "rqc_kraus = Kraus(random_quantum_channel(2, 2))\n", + "rqc_kraus" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "7e01d90f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "QuantumError on 1 qubits. Noise circuits:\n", + " P(0) = 0.05, Circuit = \n", + " ┌───┐\n", + "q: ┤ X ├\n", + " └───┘\n", + " P(1) = 0.95, Circuit = \n", + " ┌───┐\n", + "q: ┤ I ├\n", + " └───┘\n", + "QuantumError on 1 qubits. Noise circuits:\n", + " P(0) = 0.05, Circuit = \n", + " ┌───┐\n", + "q: ┤ Z ├\n", + " └───┘\n", + " P(1) = 0.95, Circuit = \n", + " ┌───┐\n", + "q: ┤ I ├\n", + " └───┘\n" + ] + } + ], + "source": [ + "# Construct a 1-qubit bit-flip and phase-flip errors\n", + "p_error = 0.05\n", + "bit_flip = pauli_error([('X', p_error), ('I', 1 - p_error)])\n", + "phase_flip = pauli_error([('Z', p_error), ('I', 1 - p_error)])\n", + "print(bit_flip)\n", + "print(phase_flip)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7c6e6e01", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "QuantumError on 1 qubits. Noise circuits:\n", + " P(0) = 0.0025000000000000005, Circuit = \n", + " ┌───┐┌───┐\n", + "q: ┤ X ├┤ Z ├\n", + " └───┘└───┘\n", + " P(1) = 0.0475, Circuit = \n", + " ┌───┐┌───┐\n", + "q: ┤ X ├┤ I ├\n", + " └───┘└───┘\n", + " P(2) = 0.0475, Circuit = \n", + " ┌───┐┌───┐\n", + "q: ┤ I ├┤ Z ├\n", + " └───┘└───┘\n", + " P(3) = 0.9025, Circuit = \n", + " ┌───┐┌───┐\n", + "q: ┤ I ├┤ I ├\n", + " └───┘└───┘\n" + ] + } + ], + "source": [ + "# Compose two bit-flip and phase-flip errors\n", + "bitphase_flip = bit_flip.compose(phase_flip)\n", + "print(bitphase_flip)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "befa5ca0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "QuantumError on 2 qubits. Noise circuits:\n", + " P(0) = 0.0025000000000000005, Circuit = \n", + " ┌───┐\n", + "q_0: ┤ X ├\n", + " ├───┤\n", + "q_1: ┤ Z ├\n", + " └───┘\n", + " P(1) = 0.0475, Circuit = \n", + " ┌───┐\n", + "q_0: ┤ I ├\n", + " ├───┤\n", + "q_1: ┤ Z ├\n", + " └───┘\n", + " P(2) = 0.0475, Circuit = \n", + " ┌───┐\n", + "q_0: ┤ X ├\n", + " ├───┤\n", + "q_1: ┤ I ├\n", + " └───┘\n", + " P(3) = 0.9025, Circuit = \n", + " ┌───┐\n", + "q_0: ┤ I ├\n", + " ├───┤\n", + "q_1: ┤ I ├\n", + " └───┘\n" + ] + } + ], + "source": [ + "# Tensor product two bit-flip and phase-flip errors with\n", + "# bit-flip on qubit-0, phase-flip on qubit-1\n", + "error2 = phase_flip.tensor(bit_flip)\n", + "print(error2)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3fc5bd41", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kraus([[[ 9.74679434e-01+0.j, 0.00000000e+00+0.j],\n", + " [ 0.00000000e+00+0.j, 9.74679434e-01+0.j]],\n", + "\n", + " [[ 0.00000000e+00+0.j, 2.23606798e-01+0.j],\n", + " [ 2.23606798e-01+0.j, -4.96506831e-17+0.j]]],\n", + " input_dims=(2,), output_dims=(2,))\n" + ] + } + ], + "source": [ + "# Convert to Kraus operator\n", + "bit_flip_kraus = Kraus(bit_flip)\n", + "print(bit_flip_kraus)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a39bbb13", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SuperOp([[1. +0.j, 0. +0.j, 0. +0.j, 0. +0.j],\n", + " [0. +0.j, 0.9+0.j, 0. +0.j, 0. +0.j],\n", + " [0. +0.j, 0. +0.j, 0.9+0.j, 0. +0.j],\n", + " [0. +0.j, 0. +0.j, 0. +0.j, 1. +0.j]],\n", + " input_dims=(2,), output_dims=(2,))\n" + ] + } + ], + "source": [ + "# Convert to Superoperator\n", + "phase_flip_sop = SuperOp(phase_flip)\n", + "print(phase_flip_sop)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "3386eb9e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "QuantumError on 1 qubits. Noise circuits:\n", + " P(0) = 1.0, Circuit = \n", + " ┌───────┐\n", + "q: ┤ kraus ├\n", + " └───────┘\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Convert back to a quantum error\n", + "print(QuantumError(bit_flip_kraus))\n", + " \n", + "# Check conversion is equivalent to original error\n", + "QuantumError(bit_flip_kraus) == bit_flip" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "d8962964", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ReadoutError([[0.95 0.05]\n", + " [0.1 0.9 ]])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Measurement misassignment probabilities\n", + "p0given1 = 0.1\n", + "p1given0 = 0.05\n", + " \n", + "ReadoutError([[1 - p1given0, p1given0], [p0given1, 1 - p0given1]])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "36ce10f5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ┌───┐ ░ ┌─┐ \n", + " q_0: ┤ H ├──■─────────────░─┤M├─────────\n", + " └───┘┌─┴─┐ ░ └╥┘┌─┐ \n", + " q_1: ─────┤ X ├──■────────░──╫─┤M├──────\n", + " └───┘┌─┴─┐ ░ ║ └╥┘┌─┐ \n", + " q_2: ──────────┤ X ├──■───░──╫──╫─┤M├───\n", + " └───┘┌─┴─┐ ░ ║ ║ └╥┘┌─┐\n", + " q_3: ───────────────┤ X ├─░──╫──╫──╫─┤M├\n", + " └───┘ ░ ║ ║ ║ └╥┘\n", + "meas: 4/════════════════════════╩══╩══╩══╩═\n", + " 0 1 2 3 \n" + ] + } + ], + "source": [ + "# System Specification\n", + "n_qubits = 4\n", + "circ = QuantumCircuit(n_qubits)\n", + " \n", + "# Test Circuit\n", + "circ.h(0)\n", + "for qubit in range(n_qubits - 1):\n", + " circ.cx(qubit, qubit + 1)\n", + "circ.measure_all()\n", + "print(circ)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "1d357ee3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 14, + "metadata": { + "image/png": { + "height": 467, + "width": 633 + } + }, + "output_type": "execute_result" + } + ], + "source": [ + "# Ideal simulator and execution\n", + "sim_ideal = AerSimulator()\n", + "result_ideal = sim_ideal.run(circ).result()\n", + "plot_histogram(result_ideal.get_counts(0))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "211fd0ba", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NoiseModel:\n", + " Basis gates: ['cx', 'id', 'rz', 'sx', 'u1', 'u2', 'u3']\n", + " Instructions with noise: ['u2', 'reset', 'u3', 'measure', 'u1', 'cx']\n", + " All-qubits errors: ['reset', 'measure', 'u1', 'u2', 'u3', 'cx']\n" + ] + } + ], + "source": [ + "# Example error probabilities\n", + "p_reset = 0.03\n", + "p_meas = 0.1\n", + "p_gate1 = 0.05\n", + " \n", + "# QuantumError objects\n", + "error_reset = pauli_error([('X', p_reset), ('I', 1 - p_reset)])\n", + "error_meas = pauli_error([('X',p_meas), ('I', 1 - p_meas)])\n", + "error_gate1 = pauli_error([('X',p_gate1), ('I', 1 - p_gate1)])\n", + "error_gate2 = error_gate1.tensor(error_gate1)\n", + " \n", + "# Add errors to noise model\n", + "noise_bit_flip = NoiseModel()\n", + "noise_bit_flip.add_all_qubit_quantum_error(error_reset, \"reset\")\n", + "noise_bit_flip.add_all_qubit_quantum_error(error_meas, \"measure\")\n", + "noise_bit_flip.add_all_qubit_quantum_error(error_gate1, [\"u1\", \"u2\", \"u3\"])\n", + "noise_bit_flip.add_all_qubit_quantum_error(error_gate2, [\"cx\"])\n", + " \n", + "print(noise_bit_flip)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "8103d7dc", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/homebrew/Caskroom/miniforge/base/lib/python3.10/site-packages/numpy/linalg/linalg.py:2154: RuntimeWarning: divide by zero encountered in det\n", + " r = _umath_linalg.det(a, signature=signature)\n", + "/opt/homebrew/Caskroom/miniforge/base/lib/python3.10/site-packages/numpy/linalg/linalg.py:2154: RuntimeWarning: invalid value encountered in det\n", + " r = _umath_linalg.det(a, signature=signature)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 16, + "metadata": { + "image/png": { + "height": 467, + "width": 633 + } + }, + "output_type": "execute_result" + } + ], + "source": [ + "# Create noisy simulator backend\n", + "sim_noise = AerSimulator(noise_model=noise_bit_flip)\n", + " \n", + "# Transpile circuit for noisy basis gates\n", + "passmanager = generate_preset_pass_manager(optimization_level=3, backend=sim_noise)\n", + "circ_tnoise = passmanager.run(circ)\n", + " \n", + "# Run and get counts\n", + "result_bit_flip = sim_noise.run(circ_tnoise).result()\n", + "counts_bit_flip = result_bit_flip.get_counts(0)\n", + " \n", + "# Plot noisy output\n", + "plot_histogram(counts_bit_flip)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.8 ('base')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + }, + "vscode": { + "interpreter": { + "hash": "4e8ef2f9fcac0817bca9a7ca376f64f20b4df5ea3bf7af756a50bda7d3557ea6" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/_build/.jupyter_cache/executed/53c7205f116c26c51b9beae7128dc5bc/base.ipynb b/_build/.jupyter_cache/executed/53c7205f116c26c51b9beae7128dc5bc/base.ipynb new file mode 100644 index 0000000..5be1783 --- /dev/null +++ b/_build/.jupyter_cache/executed/53c7205f116c26c51b9beae7128dc5bc/base.ipynb @@ -0,0 +1,430 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "5482b331", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit import QuantumCircuit\n", + "from qiskit_aer import AerSimulator\n", + "from qiskit.quantum_info import Kraus, SuperOp, random_quantum_channel, PTM, Choi, Chi\n", + "from qiskit.visualization import plot_histogram\n", + "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n", + "\n", + "# Import from Qiskit Aer noise module\n", + "from qiskit_aer.noise import (\n", + " NoiseModel,\n", + " QuantumError,\n", + " ReadoutError,\n", + " depolarizing_error,\n", + " pauli_error,\n", + " thermal_relaxation_error,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a4b2376e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Stinespring([[-1.84796689e-01+4.83217328e-02j,\n", + " 3.99955719e-01-2.48291212e-01j],\n", + " [ 5.96016205e-01+6.09589027e-02j,\n", + " -3.12358221e-02-5.05571346e-02j],\n", + " [ 3.33019089e-01-5.17947047e-01j,\n", + " -9.34057539e-02+2.37915475e-01j],\n", + " [ 1.19865525e-01+2.31413847e-01j,\n", + " 3.56704809e-02+4.30014803e-01j],\n", + " [-3.24384603e-01-1.28544091e-01j,\n", + " -2.63861055e-01+9.89309197e-02j],\n", + " [ 6.69170877e-02+1.37804433e-01j,\n", + " 9.98885126e-02+5.67348315e-01j],\n", + " [ 6.28553829e-03-5.95132179e-02j,\n", + " -3.05303074e-01-3.98991394e-02j],\n", + " [ 1.20864703e-04-9.31378629e-02j,\n", + " -1.31407241e-01+3.08098537e-04j]],\n", + " input_dims=(2,), output_dims=(2,))" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## random quantum channel in Stinespring form\n", + "from qiskit.quantum_info import random_quantum_channel\n", + "random_quantum_channel(2, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9eadfea1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "num_qubits: 1\n" + ] + }, + { + "data": { + "text/plain": [ + "PTM([[ 1.00000000e+00+5.43524853e-19j, -6.93889390e-17+1.38777878e-17j,\n", + " -4.16333634e-17+0.00000000e+00j, 1.11022302e-16+9.37659175e-18j],\n", + " [-4.27078280e-01+0.00000000e+00j, 7.95246871e-03+0.00000000e+00j,\n", + " -1.43499917e-02+0.00000000e+00j, -1.77472031e-02+0.00000000e+00j],\n", + " [ 2.57450076e-01+0.00000000e+00j, 1.73501826e-01+0.00000000e+00j,\n", + " 1.51773091e-01+0.00000000e+00j, 1.21362615e-02+0.00000000e+00j],\n", + " [-3.31656669e-01+8.61052764e-18j, 8.74606271e-02+0.00000000e+00j,\n", + " 3.24536178e-01+0.00000000e+00j, 2.22823308e-01-4.31378871e-18j]],\n", + " input_dims=(2,), output_dims=(2,))" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rqc = PTM(random_quantum_channel(2, 2))\n", + "print('num_qubits: ', rqc.num_qubits)\n", + "rqc" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d5e0cce4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "PTM([[ 1.00000000e+00-7.94966123e-18j, -6.74541368e-17+1.48082331e-17j,\n", + " -1.09257032e-17+2.84389711e-18j, 1.36486845e-16+1.12196230e-17j],\n", + " [-4.28283035e-01-3.84940442e-19j, -3.97868952e-03-5.92690175e-18j,\n", + " -8.05166994e-03+0.00000000e+00j, -4.26977984e-03-3.92798099e-18j],\n", + " [ 2.18400137e-01+2.44430130e-19j, 2.87741214e-02+3.57283753e-18j,\n", + " 2.44839774e-02+0.00000000e+00j, 1.46702770e-03+2.36165099e-18j],\n", + " [-3.59358175e-01+1.17795870e-17j, 7.64914137e-02-4.97994754e-18j,\n", + " 1.20315025e-01-1.39998050e-18j, 5.20367010e-02-5.03223453e-18j]],\n", + " input_dims=(2,), output_dims=(2,))" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rqc.compose(rqc)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a656e232", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rqc.power(4)\n", + "rqc.adjoint()\n", + "rqc.is_unitary()\n", + "rqc.is_cptp() # cp, tp, unitary" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a8692063", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Kraus([[[-0.21937625-0.3432328j , 0.04299193-0.00354056j],\n", + " [-0.13219999-0.01223734j, -0.42600098+0.22683753j]],\n", + "\n", + " [[-0.14047125-0.13301201j, 0.44918203+0.35293566j],\n", + " [ 0.23139116+0.10174378j, -0.07922607+0.14796983j]],\n", + "\n", + " [[-0.11802655+0.06385861j, 0.42335462+0.155765j ],\n", + " [ 0.39481031-0.40751119j, -0.00957106-0.19313002j]],\n", + "\n", + " [[ 0.38444718-0.18631373j, 0.19457416+0.32520188j],\n", + " [ 0.43185509+0.07849005j, 0.0702214 -0.14586998j]]],\n", + " input_dims=(2,), output_dims=(2,))" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.quantum_info import Kraus\n", + "rqc_kraus = Kraus(random_quantum_channel(2, 2))\n", + "rqc_kraus" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e31b9be2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "SuperOp([[ 0.28793863-1.45385027e-18j, 0.30452688+1.29052334e-01j,\n", + " 0.30452688-1.29052334e-01j, 0.66223641-1.12120469e-17j],\n", + " [-0.12479291+3.72730842e-01j, 0.05868011-1.65638036e-01j,\n", + " 0.10320367+4.67896567e-01j, 0.08994902-3.25730486e-01j],\n", + " [-0.12479291-3.72730842e-01j, 0.10320367-4.67896567e-01j,\n", + " 0.05868011+1.65638036e-01j, 0.08994902+3.25730486e-01j],\n", + " [ 0.71206137-2.06229643e-18j, -0.30452688-1.29052334e-01j,\n", + " -0.30452688+1.29052334e-01j, 0.33776359-1.93357060e-18j]],\n", + " input_dims=(2,), output_dims=(2,))" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.quantum_info import SuperOp\n", + "rqc_superop = SuperOp(random_quantum_channel(2, 2))\n", + "rqc_superop" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "5cb1724d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Choi([[ 0.29232812-1.03017860e-18j, -0.04411638-5.52416986e-02j,\n", + " 0.06807375+5.94847680e-02j, 0.00937887-6.18174517e-02j],\n", + " [-0.04411638+5.52416986e-02j, 0.70767188+1.09127593e-17j,\n", + " -0.06718603+2.37526207e-01j, -0.06807375-5.94847680e-02j],\n", + " [ 0.06807375-5.94847680e-02j, -0.06718603-2.37526207e-01j,\n", + " 0.70568983-1.15906241e-17j, -0.26141011-2.99664069e-01j],\n", + " [ 0.00937887+6.18174517e-02j, -0.06807375+5.94847680e-02j,\n", + " -0.26141011+2.99664069e-01j, 0.29431017+7.18027144e-18j]],\n", + " input_dims=(2,), output_dims=(2,))" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.quantum_info import Choi\n", + "\n", + "rqc_choi = Choi(random_quantum_channel(2, 2))\n", + "rqc_choi" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "88c545fd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Chi([[ 0.45948097-6.93889390e-18j, 0.02525234-1.73527806e-01j,\n", + " -0.11609877+2.65623876e-02j, -0.11711756+1.23280302e-01j],\n", + " [ 0.02525234+1.73527806e-01j, 0.47353862-1.38777878e-17j,\n", + " -0.22282147+1.17117564e-01j, 0.10980373-1.16098768e-01j],\n", + " [-0.11609877-2.65623876e-02j, -0.22282147-1.17117564e-01j,\n", + " 0.61001985+1.38777878e-17j, 0.19066813-2.52523440e-02j],\n", + " [-0.11711756-1.23280302e-01j, 0.10980373+1.16098768e-01j,\n", + " 0.19066813+2.52523440e-02j, 0.45696056-6.93889390e-18j]],\n", + " input_dims=(2,), output_dims=(2,))" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.quantum_info import Chi\n", + "rqc_chi = Chi(random_quantum_channel(2, 2))\n", + "rqc_chi" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "1e31f7fc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.5787893590846312" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.quantum_info import average_gate_fidelity\n", + "average_gate_fidelity(random_quantum_channel(2, 2))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c19ce54b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.6509548538932426" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.quantum_info import process_fidelity\n", + "process_fidelity(random_quantum_channel(2, 2), random_quantum_channel(2, 2))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "27913856", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.5403282197105239" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.quantum_info import gate_error\n", + "gate_error(random_quantum_channel(2, 2))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "a3ae5f49", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "QuantumError on 1 qubits. Noise circuits:\n", + " P(0) = 0.01, Circuit = \n", + " ┌───┐\n", + "q: ┤ X ├\n", + " └───┘\n", + " P(1) = 0.01, Circuit = \n", + " ┌───┐\n", + "q: ┤ Y ├\n", + " └───┘\n", + " P(2) = 0.01, Circuit = \n", + " ┌───┐\n", + "q: ┤ Z ├\n", + " └───┘\n", + " P(3) = 0.97, Circuit = \n", + " ┌───┐\n", + "q: ┤ I ├\n", + " └───┘\n", + "diamond distance: 0.06000010519101877 with noise rate 0.03\n" + ] + } + ], + "source": [ + "from qiskit.quantum_info import diamond_norm, random_quantum_channel\n", + "diamond_norm(random_quantum_channel(2, 2)-random_quantum_channel(2, 2))\n", + "\n", + "from qiskit.quantum_info import diamond_norm, random_quantum_channel\n", + "from qiskit.quantum_info import Kraus, SuperOp, PTM\n", + "\n", + "# diamond_norm(random_quantum_channel(2, 2)-random_quantum_channel(2, 2))\n", + "## single qubit depolarizing channel\n", + "from qiskit_aer.noise import (pauli_error)\n", + "# error = depolarizing_error(0.05, 1)\n", + "# error\n", + "p_error = 0.03\n", + "ic = pauli_error([('I', 1)])\n", + "dep_err = pauli_error([('X', p_error/3), ('Y', p_error/3), ('Z', p_error/3), ('I', 1 - p_error)])\n", + "print(dep_err)\n", + "dep_ptm = PTM(dep_err)\n", + "dep_ptm\n", + "print(f'diamond distance: {diamond_norm(dep_ptm - ic)} with noise rate {p_error}')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.8 ('base')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + }, + "vscode": { + "interpreter": { + "hash": "4e8ef2f9fcac0817bca9a7ca376f64f20b4df5ea3bf7af756a50bda7d3557ea6" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/_build/.jupyter_cache/global.db b/_build/.jupyter_cache/global.db index cc6dbb1..8954d7d 100644 Binary files a/_build/.jupyter_cache/global.db and b/_build/.jupyter_cache/global.db differ diff --git a/_build/html/_images/cd5316f044949aa24e1172f83967c5bcd6107c6e1129631e7040954039774876.png b/_build/html/_images/cd5316f044949aa24e1172f83967c5bcd6107c6e1129631e7040954039774876.png new file mode 100644 index 0000000..ad29c91 Binary files /dev/null and b/_build/html/_images/cd5316f044949aa24e1172f83967c5bcd6107c6e1129631e7040954039774876.png differ diff --git a/_build/html/_images/fae03f46edc8aad7728c010ae146d98da601ec6ded973ab4ca89ddde0f5f4ee6.png b/_build/html/_images/fae03f46edc8aad7728c010ae146d98da601ec6ded973ab4ca89ddde0f5f4ee6.png new file mode 100644 index 0000000..f2a5bc0 Binary files /dev/null and b/_build/html/_images/fae03f46edc8aad7728c010ae146d98da601ec6ded973ab4ca89ddde0f5f4ee6.png differ diff --git a/_build/html/_sources/channel.ipynb b/_build/html/_sources/channel.ipynb index 4be6f8d..d039cc0 100644 --- a/_build/html/_sources/channel.ipynb +++ b/_build/html/_sources/channel.ipynb @@ -5,7 +5,9 @@ "id": "8b24f5d3", "metadata": {}, "source": [ - "# Channels" + "# Channels\n", + "\n", + "- John Watrous: https://youtu.be/cMl-xIDSmXI" ] }, { @@ -467,426 +469,6 @@ "print(f'diamond distance: {diamond_norm(dep_ptm - ic)} with noise rate {p_error}')" ] }, - { - "cell_type": "markdown", - "id": "a299aec9", - "metadata": {}, - "source": [ - "## Noise channel" - ] - }, - { - "cell_type": "markdown", - "id": "71d0e6a6", - "metadata": {}, - "source": [ - "https://docs.quantum.ibm.com/guides/build-noise-models#build-noise-models" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "7e01d90f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "QuantumError on 1 qubits. Noise circuits:\n", - " P(0) = 0.05, Circuit = \n", - " ┌───┐\n", - "q: ┤ X ├\n", - " └───┘\n", - " P(1) = 0.95, Circuit = \n", - " ┌───┐\n", - "q: ┤ I ├\n", - " └───┘\n", - "QuantumError on 1 qubits. Noise circuits:\n", - " P(0) = 0.05, Circuit = \n", - " ┌───┐\n", - "q: ┤ Z ├\n", - " └───┘\n", - " P(1) = 0.95, Circuit = \n", - " ┌───┐\n", - "q: ┤ I ├\n", - " └───┘\n" - ] - } - ], - "source": [ - "# Construct a 1-qubit bit-flip and phase-flip errors\n", - "p_error = 0.05\n", - "bit_flip = pauli_error([('X', p_error), ('I', 1 - p_error)])\n", - "phase_flip = pauli_error([('Z', p_error), ('I', 1 - p_error)])\n", - "print(bit_flip)\n", - "print(phase_flip)" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "7c6e6e01", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "QuantumError on 1 qubits. Noise circuits:\n", - " P(0) = 0.0025000000000000005, Circuit = \n", - " ┌───┐┌───┐\n", - "q: ┤ X ├┤ Z ├\n", - " └───┘└───┘\n", - " P(1) = 0.0475, Circuit = \n", - " ┌───┐┌───┐\n", - "q: ┤ X ├┤ I ├\n", - " └───┘└───┘\n", - " P(2) = 0.0475, Circuit = \n", - " ┌───┐┌───┐\n", - "q: ┤ I ├┤ Z ├\n", - " └───┘└───┘\n", - " P(3) = 0.9025, Circuit = \n", - " ┌───┐┌───┐\n", - "q: ┤ I ├┤ I ├\n", - " └───┘└───┘\n" - ] - } - ], - "source": [ - "# Compose two bit-flip and phase-flip errors\n", - "bitphase_flip = bit_flip.compose(phase_flip)\n", - "print(bitphase_flip)" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "befa5ca0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "QuantumError on 2 qubits. Noise circuits:\n", - " P(0) = 0.0025000000000000005, Circuit = \n", - " ┌───┐\n", - "q_0: ┤ X ├\n", - " ├───┤\n", - "q_1: ┤ Z ├\n", - " └───┘\n", - " P(1) = 0.0475, Circuit = \n", - " ┌───┐\n", - "q_0: ┤ I ├\n", - " ├───┤\n", - "q_1: ┤ Z ├\n", - " └───┘\n", - " P(2) = 0.0475, Circuit = \n", - " ┌───┐\n", - "q_0: ┤ X ├\n", - " ├───┤\n", - "q_1: ┤ I ├\n", - " └───┘\n", - " P(3) = 0.9025, Circuit = \n", - " ┌───┐\n", - "q_0: ┤ I ├\n", - " ├───┤\n", - "q_1: ┤ I ├\n", - " └───┘\n" - ] - } - ], - "source": [ - "# Tensor product two bit-flip and phase-flip errors with\n", - "# bit-flip on qubit-0, phase-flip on qubit-1\n", - "error2 = phase_flip.tensor(bit_flip)\n", - "print(error2)" - ] - }, - { - "cell_type": "markdown", - "id": "7e2d98e7", - "metadata": {}, - "source": [ - "#### Converting to and from QuantumChannel operators" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "3fc5bd41", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Kraus([[[ 9.74679434e-01+0.j, 0.00000000e+00+0.j],\n", - " [ 0.00000000e+00+0.j, 9.74679434e-01+0.j]],\n", - "\n", - " [[ 0.00000000e+00+0.j, 2.23606798e-01+0.j],\n", - " [ 2.23606798e-01+0.j, -4.96506831e-17+0.j]]],\n", - " input_dims=(2,), output_dims=(2,))\n" - ] - } - ], - "source": [ - "# Convert to Kraus operator\n", - "bit_flip_kraus = Kraus(bit_flip)\n", - "print(bit_flip_kraus)" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "id": "a39bbb13", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SuperOp([[1. +0.j, 0. +0.j, 0. +0.j, 0. +0.j],\n", - " [0. +0.j, 0.9+0.j, 0. +0.j, 0. +0.j],\n", - " [0. +0.j, 0. +0.j, 0.9+0.j, 0. +0.j],\n", - " [0. +0.j, 0. +0.j, 0. +0.j, 1. +0.j]],\n", - " input_dims=(2,), output_dims=(2,))\n" - ] - } - ], - "source": [ - "# Convert to Superoperator\n", - "phase_flip_sop = SuperOp(phase_flip)\n", - "print(phase_flip_sop)" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "id": "3386eb9e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "QuantumError on 1 qubits. Noise circuits:\n", - " P(0) = 1.0, Circuit = \n", - " ┌───────┐\n", - "q: ┤ kraus ├\n", - " └───────┘\n" - ] - }, - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Convert back to a quantum error\n", - "print(QuantumError(bit_flip_kraus))\n", - " \n", - "# Check conversion is equivalent to original error\n", - "QuantumError(bit_flip_kraus) == bit_flip" - ] - }, - { - "cell_type": "markdown", - "id": "771a4028", - "metadata": {}, - "source": [ - "### Readout error" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "d8962964", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "ReadoutError([[0.95 0.05]\n", - " [0.1 0.9 ]])" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Measurement misassignment probabilities\n", - "p0given1 = 0.1\n", - "p1given0 = 0.05\n", - " \n", - "ReadoutError([[1 - p1given0, p1given0], [p0given1, 1 - p0given1]])" - ] - }, - { - "cell_type": "markdown", - "id": "c59262fa", - "metadata": {}, - "source": [ - "### Examples" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "36ce10f5", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ┌───┐ ░ ┌─┐ \n", - " q_0: ┤ H ├──■─────────────░─┤M├─────────\n", - " └───┘┌─┴─┐ ░ └╥┘┌─┐ \n", - " q_1: ─────┤ X ├──■────────░──╫─┤M├──────\n", - " └───┘┌─┴─┐ ░ ║ └╥┘┌─┐ \n", - " q_2: ──────────┤ X ├──■───░──╫──╫─┤M├───\n", - " └───┘┌─┴─┐ ░ ║ ║ └╥┘┌─┐\n", - " q_3: ───────────────┤ X ├─░──╫──╫──╫─┤M├\n", - " └───┘ ░ ║ ║ ║ └╥┘\n", - "meas: 4/════════════════════════╩══╩══╩══╩═\n", - " 0 1 2 3 \n" - ] - } - ], - "source": [ - "# System Specification\n", - "n_qubits = 4\n", - "circ = QuantumCircuit(n_qubits)\n", - " \n", - "# Test Circuit\n", - "circ.h(0)\n", - "for qubit in range(n_qubits - 1):\n", - " circ.cx(qubit, qubit + 1)\n", - "circ.measure_all()\n", - "print(circ)" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "1d357ee3", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 30, - "metadata": { - "image/png": { - "height": 467, - "width": 633 - } - }, - "output_type": "execute_result" - } - ], - "source": [ - "# Ideal simulator and execution\n", - "sim_ideal = AerSimulator()\n", - "result_ideal = sim_ideal.run(circ).result()\n", - "plot_histogram(result_ideal.get_counts(0))" - ] - }, - { - "cell_type": "markdown", - "id": "9c28a9db", - "metadata": {}, - "source": [ - "#### from qiskit_aer import AerSimulator" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "211fd0ba", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "NoiseModel:\n", - " Basis gates: ['cx', 'id', 'rz', 'sx', 'u1', 'u2', 'u3']\n", - " Instructions with noise: ['u1', 'u2', 'cx', 'u3', 'reset', 'measure']\n", - " All-qubits errors: ['reset', 'measure', 'u1', 'u2', 'u3', 'cx']\n" - ] - } - ], - "source": [ - "# Example error probabilities\n", - "p_reset = 0.03\n", - "p_meas = 0.1\n", - "p_gate1 = 0.05\n", - " \n", - "# QuantumError objects\n", - "error_reset = pauli_error([('X', p_reset), ('I', 1 - p_reset)])\n", - "error_meas = pauli_error([('X',p_meas), ('I', 1 - p_meas)])\n", - "error_gate1 = pauli_error([('X',p_gate1), ('I', 1 - p_gate1)])\n", - "error_gate2 = error_gate1.tensor(error_gate1)\n", - " \n", - "# Add errors to noise model\n", - "noise_bit_flip = NoiseModel()\n", - "noise_bit_flip.add_all_qubit_quantum_error(error_reset, \"reset\")\n", - "noise_bit_flip.add_all_qubit_quantum_error(error_meas, \"measure\")\n", - "noise_bit_flip.add_all_qubit_quantum_error(error_gate1, [\"u1\", \"u2\", \"u3\"])\n", - "noise_bit_flip.add_all_qubit_quantum_error(error_gate2, [\"cx\"])\n", - " \n", - "print(noise_bit_flip)" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "8103d7dc", - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'generate_preset_pass_manager' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[32], line 5\u001b[0m\n\u001b[1;32m 2\u001b[0m sim_noise \u001b[38;5;241m=\u001b[39m AerSimulator(noise_model\u001b[38;5;241m=\u001b[39mnoise_bit_flip)\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m# Transpile circuit for noisy basis gates\u001b[39;00m\n\u001b[0;32m----> 5\u001b[0m passmanager \u001b[38;5;241m=\u001b[39m \u001b[43mgenerate_preset_pass_manager\u001b[49m(optimization_level\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m3\u001b[39m, backend\u001b[38;5;241m=\u001b[39msim_noise)\n\u001b[1;32m 6\u001b[0m circ_tnoise \u001b[38;5;241m=\u001b[39m passmanager\u001b[38;5;241m.\u001b[39mrun(circ)\n\u001b[1;32m 8\u001b[0m \u001b[38;5;66;03m# Run and get counts\u001b[39;00m\n", - "\u001b[0;31mNameError\u001b[0m: name 'generate_preset_pass_manager' is not defined" - ] - } - ], - "source": [ - "# Create noisy simulator backend\n", - "sim_noise = AerSimulator(noise_model=noise_bit_flip)\n", - " \n", - "# Transpile circuit for noisy basis gates\n", - "passmanager = generate_preset_pass_manager(optimization_level=3, backend=sim_noise)\n", - "circ_tnoise = passmanager.run(circ)\n", - " \n", - "# Run and get counts\n", - "result_bit_flip = sim_noise.run(circ_tnoise).result()\n", - "counts_bit_flip = result_bit_flip.get_counts(0)\n", - " \n", - "# Plot noisy output\n", - "plot_histogram(counts_bit_flip)" - ] - }, { "cell_type": "markdown", "id": "e10f3644", diff --git a/_build/html/_sources/error.ipynb b/_build/html/_sources/error.ipynb new file mode 100644 index 0000000..80bfa81 --- /dev/null +++ b/_build/html/_sources/error.ipynb @@ -0,0 +1,646 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8b24f5d3", + "metadata": {}, + "source": [ + "# Noise and Error\n", + "\n", + "- Qiskit tutorial: https://youtu.be/w--HZ4QXugA" + ] + }, + { + "cell_type": "markdown", + "id": "118e6f33", + "metadata": {}, + "source": [ + "- Incoherent error: loss of quantum information in the form of superposition and entanglement \n", + "- coherent error in gate: incorrect Hamiltonian evolution\n", + "- state preparation and readout (SPAM) errors" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "5482b331", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit import QuantumCircuit\n", + "from qiskit_aer import AerSimulator\n", + "from qiskit.quantum_info import Kraus, SuperOp, random_quantum_channel, PTM, Choi, Chi\n", + "from qiskit.visualization import plot_histogram\n", + "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n", + "\n", + "# Import from Qiskit Aer noise module\n", + "from qiskit_aer.noise import (\n", + " NoiseModel,\n", + " QuantumError,\n", + " ReadoutError,\n", + " depolarizing_error,\n", + " pauli_error,\n", + " thermal_relaxation_error,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "ddc7b1fd", + "metadata": {}, + "source": [ + "## Representation" + ] + }, + { + "cell_type": "markdown", + "id": "398ba931", + "metadata": {}, + "source": [ + "### Pauli Transfer Matrix (PTM) \n", + "https://docs.quantum.ibm.com/api/qiskit/qiskit.quantum_info.PTM\n", + "\n", + "Pauli Transfer Matrix (PTM) representation of a Quantum Channel.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "id": "9eadfea1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "num_qubits: 1\n" + ] + }, + { + "data": { + "text/plain": [ + "PTM([[ 1.00000000e+00-9.52787305e-18j, -2.08166817e-17+0.00000000e+00j,\n", + " 2.77555756e-17+0.00000000e+00j, -3.33066907e-16-6.88837700e-18j],\n", + " [-9.09489194e-02+0.00000000e+00j, -3.72195758e-01+0.00000000e+00j,\n", + " 2.01356134e-02+0.00000000e+00j, -1.88193128e-01+0.00000000e+00j],\n", + " [ 1.07371749e-01+0.00000000e+00j, 3.69139869e-01+0.00000000e+00j,\n", + " -1.20645755e-01+0.00000000e+00j, -4.81331497e-01+0.00000000e+00j],\n", + " [-1.56748013e-01+8.54415943e-18j, 1.14009043e-01+0.00000000e+00j,\n", + " -4.85784633e-01+0.00000000e+00j, -1.72685021e-01+4.62303219e-19j]],\n", + " input_dims=(2,), output_dims=(2,))" + ] + }, + "execution_count": 96, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rqc = PTM(random_quantum_channel(2, 2))\n", + "print('num_qubits: ', rqc.num_qubits)\n", + "rqc" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "d5e0cce4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "PTM([[ 1.00000000e+00-2.40259894e-18j, -3.65286159e-17+1.06400890e-17j,\n", + " -3.25381917e-17-3.48337848e-19j, 8.10475729e-17-2.95275781e-18j],\n", + " [-5.03863959e-01-3.97212202e-18j, 8.72077238e-02+7.41407448e-18j,\n", + " -4.36095725e-02-9.82187287e-18j, -2.73736239e-02+4.42821287e-18j],\n", + " [ 3.66501244e-01+1.11459993e-17j, -5.33738689e-02-5.89698216e-18j,\n", + " 8.10998407e-02-1.25503009e-17j, -9.32187871e-02+2.08189613e-18j],\n", + " [-2.18558871e-01-7.45593673e-18j, 5.86923694e-02-9.37442687e-18j,\n", + " 2.00888015e-01-1.19893761e-17j, -7.11955275e-03-7.38513938e-19j]],\n", + " input_dims=(2,), output_dims=(2,))" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rqc.compose(rqc)" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "a656e232", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rqc.power(4)\n", + "rqc.adjoint()\n", + "rqc.is_unitary()\n", + "rqc.is_cptp() # cp, tp, unitary" + ] + }, + { + "cell_type": "markdown", + "id": "f2d144cc", + "metadata": {}, + "source": [ + "### Kraus" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "id": "a8692063", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Kraus([[[ 0.40797192-0.21907435j, -0.04302789-0.46760563j],\n", + " [-0.02762658-0.30734793j, -0.02968974+0.05646335j]],\n", + "\n", + " [[-0.31594324-0.24582982j, 0.22465833-0.25842112j],\n", + " [-0.29698492+0.15016866j, 0.33448024-0.03782379j]],\n", + "\n", + " [[ 0.29609313-0.1089395j , 0.17119268-0.49213072j],\n", + " [-0.19383795-0.15392175j, 0.30024441-0.14315255j]],\n", + "\n", + " [[ 0.15164906-0.06327016j, 0.22433035+0.00823283j],\n", + " [ 0.47619079-0.06909437j, -0.07334134+0.32703776j]]],\n", + " input_dims=(2,), output_dims=(2,))" + ] + }, + "execution_count": 132, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.quantum_info import Kraus\n", + "rqc_kraus = Kraus(random_quantum_channel(2, 2))\n", + "rqc_kraus" + ] + }, + { + "cell_type": "markdown", + "id": "a299aec9", + "metadata": {}, + "source": [ + "## Noise channel" + ] + }, + { + "cell_type": "markdown", + "id": "71d0e6a6", + "metadata": {}, + "source": [ + "https://docs.quantum.ibm.com/guides/build-noise-models#build-noise-models" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "7e01d90f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "QuantumError on 1 qubits. Noise circuits:\n", + " P(0) = 0.05, Circuit = \n", + " ┌───┐\n", + "q: ┤ X ├\n", + " └───┘\n", + " P(1) = 0.95, Circuit = \n", + " ┌───┐\n", + "q: ┤ I ├\n", + " └───┘\n", + "QuantumError on 1 qubits. Noise circuits:\n", + " P(0) = 0.05, Circuit = \n", + " ┌───┐\n", + "q: ┤ Z ├\n", + " └───┘\n", + " P(1) = 0.95, Circuit = \n", + " ┌───┐\n", + "q: ┤ I ├\n", + " └───┘\n" + ] + } + ], + "source": [ + "# Construct a 1-qubit bit-flip and phase-flip errors\n", + "p_error = 0.05\n", + "bit_flip = pauli_error([('X', p_error), ('I', 1 - p_error)])\n", + "phase_flip = pauli_error([('Z', p_error), ('I', 1 - p_error)])\n", + "print(bit_flip)\n", + "print(phase_flip)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "7c6e6e01", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "QuantumError on 1 qubits. Noise circuits:\n", + " P(0) = 0.0025000000000000005, Circuit = \n", + " ┌───┐┌───┐\n", + "q: ┤ X ├┤ Z ├\n", + " └───┘└───┘\n", + " P(1) = 0.0475, Circuit = \n", + " ┌───┐┌───┐\n", + "q: ┤ X ├┤ I ├\n", + " └───┘└───┘\n", + " P(2) = 0.0475, Circuit = \n", + " ┌───┐┌───┐\n", + "q: ┤ I ├┤ Z ├\n", + " └───┘└───┘\n", + " P(3) = 0.9025, Circuit = \n", + " ┌───┐┌───┐\n", + "q: ┤ I ├┤ I ├\n", + " └───┘└───┘\n" + ] + } + ], + "source": [ + "# Compose two bit-flip and phase-flip errors\n", + "bitphase_flip = bit_flip.compose(phase_flip)\n", + "print(bitphase_flip)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "befa5ca0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "QuantumError on 2 qubits. Noise circuits:\n", + " P(0) = 0.0025000000000000005, Circuit = \n", + " ┌───┐\n", + "q_0: ┤ X ├\n", + " ├───┤\n", + "q_1: ┤ Z ├\n", + " └───┘\n", + " P(1) = 0.0475, Circuit = \n", + " ┌───┐\n", + "q_0: ┤ I ├\n", + " ├───┤\n", + "q_1: ┤ Z ├\n", + " └───┘\n", + " P(2) = 0.0475, Circuit = \n", + " ┌───┐\n", + "q_0: ┤ X ├\n", + " ├───┤\n", + "q_1: ┤ I ├\n", + " └───┘\n", + " P(3) = 0.9025, Circuit = \n", + " ┌───┐\n", + "q_0: ┤ I ├\n", + " ├───┤\n", + "q_1: ┤ I ├\n", + " └───┘\n" + ] + } + ], + "source": [ + "# Tensor product two bit-flip and phase-flip errors with\n", + "# bit-flip on qubit-0, phase-flip on qubit-1\n", + "error2 = phase_flip.tensor(bit_flip)\n", + "print(error2)" + ] + }, + { + "cell_type": "markdown", + "id": "7e2d98e7", + "metadata": {}, + "source": [ + "#### Converting to and from QuantumChannel operators" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "3fc5bd41", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kraus([[[ 9.74679434e-01+0.j, 0.00000000e+00+0.j],\n", + " [ 0.00000000e+00+0.j, 9.74679434e-01+0.j]],\n", + "\n", + " [[ 0.00000000e+00+0.j, 2.23606798e-01+0.j],\n", + " [ 2.23606798e-01+0.j, -4.96506831e-17+0.j]]],\n", + " input_dims=(2,), output_dims=(2,))\n" + ] + } + ], + "source": [ + "# Convert to Kraus operator\n", + "bit_flip_kraus = Kraus(bit_flip)\n", + "print(bit_flip_kraus)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "a39bbb13", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SuperOp([[1. +0.j, 0. +0.j, 0. +0.j, 0. +0.j],\n", + " [0. +0.j, 0.9+0.j, 0. +0.j, 0. +0.j],\n", + " [0. +0.j, 0. +0.j, 0.9+0.j, 0. +0.j],\n", + " [0. +0.j, 0. +0.j, 0. +0.j, 1. +0.j]],\n", + " input_dims=(2,), output_dims=(2,))\n" + ] + } + ], + "source": [ + "# Convert to Superoperator\n", + "phase_flip_sop = SuperOp(phase_flip)\n", + "print(phase_flip_sop)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "3386eb9e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "QuantumError on 1 qubits. Noise circuits:\n", + " P(0) = 1.0, Circuit = \n", + " ┌───────┐\n", + "q: ┤ kraus ├\n", + " └───────┘\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Convert back to a quantum error\n", + "print(QuantumError(bit_flip_kraus))\n", + " \n", + "# Check conversion is equivalent to original error\n", + "QuantumError(bit_flip_kraus) == bit_flip" + ] + }, + { + "cell_type": "markdown", + "id": "771a4028", + "metadata": {}, + "source": [ + "### Readout error" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d8962964", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ReadoutError([[0.95 0.05]\n", + " [0.1 0.9 ]])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Measurement misassignment probabilities\n", + "p0given1 = 0.1\n", + "p1given0 = 0.05\n", + " \n", + "ReadoutError([[1 - p1given0, p1given0], [p0given1, 1 - p0given1]])" + ] + }, + { + "cell_type": "markdown", + "id": "c59262fa", + "metadata": {}, + "source": [ + "### Examples" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "36ce10f5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ┌───┐ ░ ┌─┐ \n", + " q_0: ┤ H ├──■─────────────░─┤M├─────────\n", + " └───┘┌─┴─┐ ░ └╥┘┌─┐ \n", + " q_1: ─────┤ X ├──■────────░──╫─┤M├──────\n", + " └───┘┌─┴─┐ ░ ║ └╥┘┌─┐ \n", + " q_2: ──────────┤ X ├──■───░──╫──╫─┤M├───\n", + " └───┘┌─┴─┐ ░ ║ ║ └╥┘┌─┐\n", + " q_3: ───────────────┤ X ├─░──╫──╫──╫─┤M├\n", + " └───┘ ░ ║ ║ ║ └╥┘\n", + "meas: 4/════════════════════════╩══╩══╩══╩═\n", + " 0 1 2 3 \n" + ] + } + ], + "source": [ + "# System Specification\n", + "n_qubits = 4\n", + "circ = QuantumCircuit(n_qubits)\n", + " \n", + "# Test Circuit\n", + "circ.h(0)\n", + "for qubit in range(n_qubits - 1):\n", + " circ.cx(qubit, qubit + 1)\n", + "circ.measure_all()\n", + "print(circ)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "1d357ee3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 30, + "metadata": { + "image/png": { + "height": 467, + "width": 633 + } + }, + "output_type": "execute_result" + } + ], + "source": [ + "# Ideal simulator and execution\n", + "sim_ideal = AerSimulator()\n", + "result_ideal = sim_ideal.run(circ).result()\n", + "plot_histogram(result_ideal.get_counts(0))" + ] + }, + { + "cell_type": "markdown", + "id": "9c28a9db", + "metadata": {}, + "source": [ + "#### from qiskit_aer import AerSimulator" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "211fd0ba", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NoiseModel:\n", + " Basis gates: ['cx', 'id', 'rz', 'sx', 'u1', 'u2', 'u3']\n", + " Instructions with noise: ['u1', 'u2', 'cx', 'u3', 'reset', 'measure']\n", + " All-qubits errors: ['reset', 'measure', 'u1', 'u2', 'u3', 'cx']\n" + ] + } + ], + "source": [ + "# Example error probabilities\n", + "p_reset = 0.03\n", + "p_meas = 0.1\n", + "p_gate1 = 0.05\n", + " \n", + "# QuantumError objects\n", + "error_reset = pauli_error([('X', p_reset), ('I', 1 - p_reset)])\n", + "error_meas = pauli_error([('X',p_meas), ('I', 1 - p_meas)])\n", + "error_gate1 = pauli_error([('X',p_gate1), ('I', 1 - p_gate1)])\n", + "error_gate2 = error_gate1.tensor(error_gate1)\n", + " \n", + "# Add errors to noise model\n", + "noise_bit_flip = NoiseModel()\n", + "noise_bit_flip.add_all_qubit_quantum_error(error_reset, \"reset\")\n", + "noise_bit_flip.add_all_qubit_quantum_error(error_meas, \"measure\")\n", + "noise_bit_flip.add_all_qubit_quantum_error(error_gate1, [\"u1\", \"u2\", \"u3\"])\n", + "noise_bit_flip.add_all_qubit_quantum_error(error_gate2, [\"cx\"])\n", + " \n", + "print(noise_bit_flip)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "8103d7dc", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'generate_preset_pass_manager' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[32], line 5\u001b[0m\n\u001b[1;32m 2\u001b[0m sim_noise \u001b[38;5;241m=\u001b[39m AerSimulator(noise_model\u001b[38;5;241m=\u001b[39mnoise_bit_flip)\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m# Transpile circuit for noisy basis gates\u001b[39;00m\n\u001b[0;32m----> 5\u001b[0m passmanager \u001b[38;5;241m=\u001b[39m \u001b[43mgenerate_preset_pass_manager\u001b[49m(optimization_level\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m3\u001b[39m, backend\u001b[38;5;241m=\u001b[39msim_noise)\n\u001b[1;32m 6\u001b[0m circ_tnoise \u001b[38;5;241m=\u001b[39m passmanager\u001b[38;5;241m.\u001b[39mrun(circ)\n\u001b[1;32m 8\u001b[0m \u001b[38;5;66;03m# Run and get counts\u001b[39;00m\n", + "\u001b[0;31mNameError\u001b[0m: name 'generate_preset_pass_manager' is not defined" + ] + } + ], + "source": [ + "# Create noisy simulator backend\n", + "sim_noise = AerSimulator(noise_model=noise_bit_flip)\n", + " \n", + "# Transpile circuit for noisy basis gates\n", + "passmanager = generate_preset_pass_manager(optimization_level=3, backend=sim_noise)\n", + "circ_tnoise = passmanager.run(circ)\n", + " \n", + "# Run and get counts\n", + "result_bit_flip = sim_noise.run(circ_tnoise).result()\n", + "counts_bit_flip = result_bit_flip.get_counts(0)\n", + " \n", + "# Plot noisy output\n", + "plot_histogram(counts_bit_flip)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.8 ('base')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + }, + "vscode": { + "interpreter": { + "hash": "4e8ef2f9fcac0817bca9a7ca376f64f20b4df5ea3bf7af756a50bda7d3557ea6" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/_build/html/_sources/hamiltonian.ipynb b/_build/html/_sources/hamiltonian.ipynb index a42df1d..433eab4 100644 --- a/_build/html/_sources/hamiltonian.ipynb +++ b/_build/html/_sources/hamiltonian.ipynb @@ -4,7 +4,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Gallery of toy models" + "# Gallery of toy models\n", + "\n", + "\n", + "[An incomplete list of Quantum Simulatoin Experiments](https://almond-taurus-565.notion.site/Quantum-Simulation-Experiments-81d2c5e16d0a43af907204ec6eaf3043)" ] } ], diff --git a/_build/html/_sources/intro.md b/_build/html/_sources/intro.md index 384abdb..2764468 100644 --- a/_build/html/_sources/intro.md +++ b/_build/html/_sources/intro.md @@ -10,7 +10,7 @@ This is a pedagogic tutorial on quantum simulation with code. The package [quantum-simulation-recipe](https://youtu.be/QDPtcwhpQkE?si=_utI2VstkFiJfvxR) built with [qiskit](https://www.ibm.com/quantum/qiskit), [openfermion](https://quantumai.google/openfermion) etc. -[Qiskit tutorial](https://youtu.be/QDPtcwhpQkE?si=_utI2VstkFiJfvxR) +[Qiskit tutorial](https://youtube.com/playlist?list=PLOFEBzvs-VvrgHZt3exM_NNiNKtZlHvZi&si=PaaDp4Qjp0crOoXL) ```{tableofcontents} ``` diff --git a/_build/html/_sources/ordering.ipynb b/_build/html/_sources/ordering.ipynb index 53c2de0..7273ea7 100644 --- a/_build/html/_sources/ordering.ipynb +++ b/_build/html/_sources/ordering.ipynb @@ -13,7 +13,11 @@ "id": "ad7989ef", "metadata": {}, "source": [ - "## Randomized product formula" + "## Randomized product formula\n", + "\n", + "- [Faster quantum simulation by randomization](http://arxiv.org/abs/1805.08385)\n", + "- [A random compiler for fast Hamiltonian simulation](http://arxiv.org/abs/1811.08017)\n", + "- [High-Order Randomized Compiler for Hamiltonian Simulation](https://link.aps.org/doi/10.1103/PRXQuantum.5.020330)" ] }, { @@ -23,6 +27,32 @@ "source": [ "### QDrift" ] + }, + { + "cell_type": "markdown", + "id": "242ee5a6", + "metadata": {}, + "source": [ + "## Light-cone\n", + "\n", + "- [Observable-Driven Speed-ups in Quantum Simulations](http://arxiv.org/abs/2407.14497)" + ] + }, + { + "cell_type": "markdown", + "id": "da94646c", + "metadata": {}, + "source": [ + "## VQA" + ] + }, + { + "cell_type": "markdown", + "id": "ca76cd8a", + "metadata": {}, + "source": [ + "- https://www.youtube.com/watch?v=o_F7n9N3OrY" + ] } ], "metadata": { diff --git a/_build/html/_sources/path_integral.ipynb b/_build/html/_sources/path_integral.ipynb index b923f09..06da2dc 100644 --- a/_build/html/_sources/path_integral.ipynb +++ b/_build/html/_sources/path_integral.ipynb @@ -9,7 +9,10 @@ "\n", "Main Reference:\n", "- [A polynomial-time classical algorithm for noisy quantum circuits](http://arxiv.org/abs/2407.12768)\n", - "- [A Polynomial-Time Classical Algorithm for Noisy Random Circuit Sampling](https://arxiv.org/abs/2211.03999)" + "- [A Polynomial-Time Classical Algorithm for Noisy Random Circuit Sampling](https://arxiv.org/abs/2211.03999)\n", + "\n", + "\n", + ".... todo" ] }, { diff --git a/_build/html/_sources/trotter.ipynb b/_build/html/_sources/trotter.ipynb index 2b4bb4e..8bf0d10 100644 --- a/_build/html/_sources/trotter.ipynb +++ b/_build/html/_sources/trotter.ipynb @@ -60,22 +60,6 @@ "source": [ "## High-order product formula" ] - }, - { - "cell_type": "markdown", - "id": "ad7989ef", - "metadata": {}, - "source": [ - "## Randomized product formula" - ] - }, - { - "cell_type": "markdown", - "id": "62f719a8", - "metadata": {}, - "source": [ - "### QDrift" - ] } ], "metadata": { diff --git a/_build/html/average.html b/_build/html/average.html index b086a6f..e9e1c0a 100644 --- a/_build/html/average.html +++ b/_build/html/average.html @@ -183,6 +183,7 @@
  • States
  • Operators
  • Channels
  • +
  • Noise and Error
  • Gallery of toy models
      diff --git a/_build/html/channel.html b/_build/html/channel.html index 4553b90..6b0ac2d 100644 --- a/_build/html/channel.html +++ b/_build/html/channel.html @@ -61,7 +61,7 @@ - + @@ -183,6 +183,7 @@
    • States
    • Operators
    • Channels
    • +
    • Noise and Error
  • Gallery of toy models
      @@ -422,15 +423,6 @@

      Contents

  • Measures
  • -
  • Noise channel -
  • Measurement