From effdbad2134358b7a014429b9f72a864426d1409 Mon Sep 17 00:00:00 2001 From: Jim Garrison Date: Mon, 2 Oct 2023 12:41:29 -0400 Subject: [PATCH 01/13] Draft support for reconstructing a probability distribution --- .../cutting/cutting_decomposition.py | 4 - .../cutting/cutting_experiments.py | 38 ++ .../cutting/cutting_reconstruction.py | 22 + .../04_reconstruct_distribution.ipynb | 626 ++++++++++++++++++ test/cutting/test_cutting_decomposition.py | 9 - 5 files changed, 686 insertions(+), 13 deletions(-) create mode 100644 docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb diff --git a/circuit_knitting/cutting/cutting_decomposition.py b/circuit_knitting/cutting/cutting_decomposition.py index adeb3afa9..712d90a5e 100644 --- a/circuit_knitting/cutting/cutting_decomposition.py +++ b/circuit_knitting/cutting/cutting_decomposition.py @@ -141,10 +141,6 @@ def cut_gates( Raises: ValueError: The input circuit should contain no classical bits or registers. """ - if len(circuit.cregs) != 0 or circuit.num_clbits != 0: - raise ValueError( - "Circuits input to cut_gates should contain no classical registers or bits." - ) # Replace specified gates with TwoQubitQPDGates if not inplace: circuit = circuit.copy() diff --git a/circuit_knitting/cutting/cutting_experiments.py b/circuit_knitting/cutting/cutting_experiments.py index 1412b6d5c..e7a2ce46e 100644 --- a/circuit_knitting/cutting/cutting_experiments.py +++ b/circuit_knitting/cutting/cutting_experiments.py @@ -33,6 +33,44 @@ from .cutting_decomposition import decompose_observables +def generate_distribution_cutting_experiments( + circuit: QuantumCircuit, + num_samples: float, +): + """Generate cutting experiments for reconstructing a probability distribution.""" + # FIXME: make sure there's at least one measurement in the circuit + + if not num_samples >= 1: + raise ValueError("num_samples must be at least 1.") + + # Gather the unique bases from the circuit + bases, qpd_gate_ids = _get_bases(circuit) + + # Sample the joint quasiprobability decomposition + random_samples = generate_qpd_weights(bases, num_samples=num_samples) + + # Calculate terms in coefficient calculation + kappa = np.prod([basis.kappa for basis in bases]) + num_samples = sum([value[0] for value in random_samples.values()]) + + # Sort samples in descending order of frequency + sorted_samples = sorted(random_samples.items(), key=lambda x: x[1][0], reverse=True) + + # Generate the output experiments and their respective coefficients + subexperiments: list[QuantumCircuit] = [] + coefficients: list[tuple[float, WeightType]] = [] + for z, (map_ids, (redundancy, weight_type)) in enumerate(sorted_samples): + actual_coeff = np.prod( + [basis.coeffs[map_id] for basis, map_id in strict_zip(bases, map_ids)] + ) + sampled_coeff = (redundancy / num_samples) * (kappa * np.sign(actual_coeff)) + coefficients.append((sampled_coeff, weight_type)) + decomp_qc = decompose_qpd_instructions(circuit, qpd_gate_ids, map_ids) + subexperiments.append(decomp_qc) + + return subexperiments, coefficients + + def generate_cutting_experiments( circuits: QuantumCircuit | dict[Hashable, QuantumCircuit], observables: PauliList | dict[Hashable, PauliList], diff --git a/circuit_knitting/cutting/cutting_reconstruction.py b/circuit_knitting/cutting/cutting_reconstruction.py index ec7c68ede..70f73e9e6 100644 --- a/circuit_knitting/cutting/cutting_reconstruction.py +++ b/circuit_knitting/cutting/cutting_reconstruction.py @@ -21,10 +21,32 @@ from ..utils.observable_grouping import CommutingObservableGroup, ObservableCollection from ..utils.bitwise import bit_count +from ..utils.iteration import strict_zip from .cutting_decomposition import decompose_observables from .qpd import WeightType +def reconstruct_distribution( + results: SamplerResult, + original_circuit_num_clbits: int, + coefficients: Sequence[tuple[float, WeightType]], +): + """Reconstruct probability distribution.""" + num_meas_bits = original_circuit_num_clbits + quasi_dists_out: dict[str | int, float] = {} + for quasi_dist, (coeff, _) in strict_zip(results.quasi_dists, coefficients): + for outcome, weight in quasi_dist.items(): + # NOTE: The registers are in the opposite order compared to + # cutting_reconstruction._process_outcome. + meas_outcomes = outcome & ((1 << num_meas_bits) - 1) + qpd_outcomes = outcome >> num_meas_bits + qpd_factor = 1 - 2 * (bit_count(qpd_outcomes) & 1) + quasi_dists_out[meas_outcomes] = ( + quasi_dists_out.get(meas_outcomes, 0.0) + coeff * qpd_factor * weight + ) + return quasi_dists_out + + def reconstruct_expectation_values( results: SamplerResult | dict[Hashable, SamplerResult], coefficients: Sequence[tuple[float, WeightType]], diff --git a/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb b/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb new file mode 100644 index 000000000..f3649ae4f --- /dev/null +++ b/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb @@ -0,0 +1,626 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "7df1ec73-0201-4742-a098-2d943d082f58", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "from qiskit.circuit import QuantumCircuit, ClassicalRegister\n", + "from qiskit.circuit.library import EfficientSU2\n", + "\n", + "from circuit_knitting.cutting import cut_gates, generate_cutting_experiments\n", + "from circuit_knitting.cutting.cutting_experiments import generate_distribution_cutting_experiments\n", + "from circuit_knitting.cutting.cutting_reconstruction import reconstruct_distribution\n", + "\n", + "\n", + "def construct_circuit(num_qubits: int, num_measurements: int, reps: int = 1) -> tuple[QuantumCircuit, QuantumCircuit]:\n", + " circuit = EfficientSU2(num_qubits=num_qubits, reps=reps, entanglement=\"circular\").decompose()\n", + " circuit.assign_parameters([0.4] * len(circuit.parameters), inplace=True)\n", + "\n", + " circuit.add_register(ClassicalRegister(num_measurements))\n", + " for i in range(num_measurements):\n", + " circuit.measure(i, i)\n", + " \n", + " cut_indices = [\n", + " i\n", + " for i, instruction in enumerate(circuit.data)\n", + " if {circuit.find_bit(q)[0] for q in instruction.qubits} == {0, num_qubits - 1}\n", + " ]\n", + " circuit1, bases = cut_gates(circuit, cut_indices)\n", + "\n", + " return circuit, circuit1, bases" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7a38ff51-60da-46a9-b16f-fc6a4a00332c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "circuit0, circuit1, bases = construct_circuit(8, 4)\n", + "circuit0.draw(\"mpl\", fold=-1)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "14cdfc07-2764-4a29-bec1-cbae3ac754ed", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[(0.5, ),\n", + " (0.5, ),\n", + " (0.5, ),\n", + " (-0.5, ),\n", + " (0.5, ),\n", + " (-0.5, )]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "subexperiments, coefficients = generate_distribution_cutting_experiments(circuit1, np.inf)\n", + "coefficients" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4f17eb50-3651-43f1-8730-31772b7dcfb8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "subexperiments[0].draw(\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "3bb65e6d-6ffe-4e89-9066-dcf4f3bb988a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "subexperiments[1].draw(\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "491a35b2-4ac4-45de-9e47-7b946b40fcf0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "subexperiments[2].draw(\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "08b0dbb2-4286-4ad7-8ad9-33f22b22fec7", + "metadata": {}, + "outputs": [], + "source": [ + "from circuit_knitting.utils.simulation import ExactSampler\n", + "from qiskit_aer.primitives import Sampler as AerSampler\n", + "\n", + "def sampler_simulator(circuits, shots=None):\n", + " if shots is None:\n", + " sampler = ExactSampler()\n", + " else:\n", + " sampler = AerSampler(run_options={\"shots\": shots})\n", + " return sampler.run(circuits).result()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "0b4810f6-ac63-4409-b8fb-f6f7cffa2786", + "metadata": {}, + "outputs": [], + "source": [ + "shots = 100_000" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "09c3b376-b6f3-4511-a37a-1f56b77cc2f4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "9.0" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "overhead = np.prod([basis.overhead for basis in bases])\n", + "overhead" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "44ca6c20-6675-429c-997f-1a41ea64f3af", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{10: 0.0013611111111111111,\n", + " 6: 0.0020911111111111113,\n", + " 7: 0.03314888888888889,\n", + " 1: 0.02322888888888889,\n", + " 8: 0.028251111111111112,\n", + " 12: 0.020966666666666668,\n", + " 0: 0.30828444444444447,\n", + " 15: 0.4902577777777778,\n", + " 11: 0.011765555555555555,\n", + " 3: 0.021833333333333333,\n", + " 9: 0.004686666666666666,\n", + " 5: 0.0009577777777777778,\n", + " 2: 0.016365555555555557,\n", + " 4: 0.01491888888888889,\n", + " 14: 0.012843333333333333,\n", + " 13: 0.00903888888888889},\n", + " {10: 0.0009577777777777778,\n", + " 9: 0.005324444444444444,\n", + " 6: 0.003426666666666667,\n", + " 7: 0.02412,\n", + " 0: 0.39894555555555555,\n", + " 15: 0.34103666666666665,\n", + " 3: 0.020335555555555555,\n", + " 11: 0.00914111111111111,\n", + " 8: 0.03794555555555556,\n", + " 1: 0.04260777777777778,\n", + " 12: 0.020735555555555556,\n", + " 5: 0.0013711111111111111,\n", + " 2: 0.01848111111111111,\n", + " 4: 0.019826666666666666,\n", + " 13: 0.011588888888888888,\n", + " 14: 0.04415555555555556},\n", + " {27: 3e-05,\n", + " 21: 5e-05,\n", + " 25: 0.00016,\n", + " 23: 0.0001588888888888889,\n", + " 28: 0.0014777777777777777,\n", + " 19: 0.00022333333333333333,\n", + " 9: 0.004034444444444445,\n", + " 8: 0.06263,\n", + " 1: 0.03467666666666667,\n", + " 14: 0.03324888888888889,\n", + " 29: 5.555555555555556e-06,\n", + " 26: 4.777777777777778e-05,\n", + " 11: 0.0008166666666666667,\n", + " 24: 0.002607777777777778,\n", + " 4: 0.03209666666666667,\n", + " 15: 0.04731777777777778,\n", + " 13: 0.00012666666666666666,\n", + " 16: 0.026998888888888888,\n", + " 22: 0.00020555555555555556,\n", + " 0: 0.6603211111111111,\n", + " 7: 0.003436666666666667,\n", + " 6: 0.00417,\n", + " 31: 0.001957777777777778,\n", + " 12: 0.03671888888888889,\n", + " 20: 0.0013166666666666667,\n", + " 18: 0.0013722222222222222,\n", + " 2: 0.033368888888888885,\n", + " 5: 0.001321111111111111,\n", + " 10: 0.001458888888888889,\n", + " 30: 0.00133,\n", + " 3: 0.004893333333333334,\n", + " 17: 0.001421111111111111},\n", + " {18: 1.111111111111111e-06,\n", + " 2: 5.111111111111111e-05,\n", + " 24: 8.11111111111111e-05,\n", + " 21: 3.222222222222222e-05,\n", + " 22: 5.7777777777777776e-05,\n", + " 25: 0.00022888888888888888,\n", + " 10: 0.0007844444444444445,\n", + " 20: 6.777777777777778e-05,\n", + " 12: 0.00351,\n", + " 1: 0.02932888888888889,\n", + " 8: 0.001478888888888889,\n", + " 14: 0.021341111111111113,\n", + " 5: 0.0009022222222222222,\n", + " 31: 0.03102111111111111,\n", + " 7: 0.050903333333333335,\n", + " 27: 0.0007455555555555555,\n", + " 6: 0.0011922222222222221,\n", + " 0: 0.01906888888888889,\n", + " 4: 0.00127,\n", + " 15: 0.7502166666666666,\n", + " 9: 0.005681111111111111,\n", + " 30: 0.0009177777777777778,\n", + " 3: 0.035521111111111114,\n", + " 17: 0.0012144444444444444,\n", + " 26: 3.555555555555555e-05,\n", + " 11: 0.019003333333333334,\n", + " 29: 0.0008022222222222222,\n", + " 19: 0.0014355555555555556,\n", + " 13: 0.020063333333333332,\n", + " 16: 0.0008022222222222222,\n", + " 23: 0.002097777777777778,\n", + " 28: 0.0001422222222222222},\n", + " {25: 0.00011888888888888889,\n", + " 5: 0.0008144444444444445,\n", + " 21: 0.0003266666666666667,\n", + " 22: 0.0022833333333333334,\n", + " 9: 0.004898888888888889,\n", + " 19: 0.0035277777777777777,\n", + " 10: 0.0008144444444444445,\n", + " 31: 0.1165888888888889,\n", + " 20: 0.005651111111111111,\n", + " 12: 0.016344444444444446,\n", + " 1: 0.03247222222222222,\n", + " 8: 0.020968888888888888,\n", + " 0: 0.23047777777777778,\n", + " 7: 0.020837777777777778,\n", + " 27: 0.0033877777777777777,\n", + " 6: 0.00038666666666666667,\n", + " 24: 0.011961111111111112,\n", + " 17: 0.0007922222222222223,\n", + " 30: 0.025673333333333333,\n", + " 3: 0.017274444444444443,\n", + " 15: 0.2984011111111111,\n", + " 4: 0.01173111111111111,\n", + " 2: 0.008624444444444445,\n", + " 18: 0.00878,\n", + " 16: 0.1238511111111111,\n", + " 13: 0.004875555555555556,\n", + " 14: 0.0028344444444444446,\n", + " 23: 0.007735555555555555,\n", + " 28: 0.004613333333333333,\n", + " 26: 0.0003711111111111111,\n", + " 11: 0.007105555555555556,\n", + " 29: 0.0054755555555555556},\n", + " {25: 0.00011888888888888889,\n", + " 21: 0.00032555555555555555,\n", + " 5: 0.0008155555555555556,\n", + " 10: 0.0008133333333333333,\n", + " 19: 0.0035366666666666667,\n", + " 27: 0.0033855555555555557,\n", + " 31: 0.11657666666666666,\n", + " 7: 0.02085,\n", + " 6: 0.00038666666666666667,\n", + " 24: 0.011953333333333333,\n", + " 22: 0.0022822222222222224,\n", + " 20: 0.005648888888888889,\n", + " 12: 0.016346666666666666,\n", + " 1: 0.032466666666666665,\n", + " 8: 0.02098222222222222,\n", + " 0: 0.23046666666666665,\n", + " 17: 0.00079,\n", + " 30: 0.025676666666666667,\n", + " 3: 0.017274444444444443,\n", + " 2: 0.00862111111111111,\n", + " 18: 0.008784444444444444,\n", + " 16: 0.12385666666666667,\n", + " 13: 0.004883333333333333,\n", + " 15: 0.2983922222222222,\n", + " 4: 0.01173111111111111,\n", + " 14: 0.002832222222222222,\n", + " 26: 0.0003711111111111111,\n", + " 11: 0.0071,\n", + " 29: 0.0054755555555555556,\n", + " 23: 0.0077377777777777774,\n", + " 28: 0.004621111111111111,\n", + " 9: 0.004896666666666666}]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results = sampler_simulator(subexperiments, shots * overhead)\n", + "results.quasi_dists" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ed7c0de7-8c61-42ca-bf78-d74732b41e61", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{10: 0.0014911111111111112,\n", + " 6: 0.004173333333333333,\n", + " 7: 0.005865555555555551,\n", + " 1: 0.03549055555555556,\n", + " 8: 0.06240000000000002,\n", + " 12: 0.03679055555555556,\n", + " 0: 0.6611511111111111,\n", + " 15: 0.07872777777777779,\n", + " 11: 0.0017194444444444427,\n", + " 3: 0.00638111111111111,\n", + " 9: 0.004217777777777779,\n", + " 5: 0.0013638888888888889,\n", + " 2: 0.03340055555555556,\n", + " 4: 0.03216055555555556,\n", + " 14: 0.03425000000000001,\n", + " 13: 0.0007400000000000006}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reconstructed = reconstruct_distribution(results, circuit1.num_clbits, coefficients)\n", + "reconstructed" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "0e7596a1-8b6c-4265-98dd-169325fe9811", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{11: 0.00139,\n", + " 10: 0.00159,\n", + " 3: 0.00608,\n", + " 5: 0.0014,\n", + " 2: 0.0335,\n", + " 15: 0.07787,\n", + " 0: 0.66255,\n", + " 1: 0.03569,\n", + " 12: 0.03654,\n", + " 8: 0.06255,\n", + " 13: 0.00115,\n", + " 4: 0.03243,\n", + " 14: 0.03367,\n", + " 9: 0.00413,\n", + " 7: 0.00525,\n", + " 6: 0.00421}" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sampled = sampler_simulator(circuit0, shots).quasi_dists[0]\n", + "sampled" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "473cce82-e391-4c0f-a7e3-382c09b15bfb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{0: 0.661349383557438,\n", + " 1: 0.03573591897099262,\n", + " 2: 0.03337296608496434,\n", + " 3: 0.006388238923736263,\n", + " 4: 0.032182698035813674,\n", + " 5: 0.0013998087091053578,\n", + " 6: 0.004207492698762929,\n", + " 7: 0.005595572758886547,\n", + " 8: 0.06231788362606926,\n", + " 9: 0.004155009279367033,\n", + " 10: 0.0014955544996490613,\n", + " 11: 0.0015810929361027217,\n", + " 12: 0.036709228053622846,\n", + " 13: 0.000952453718087712,\n", + " 14: 0.03400806226188168,\n", + " 15: 0.0785486358855195}" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "exact = sampler_simulator(circuit0).quasi_dists[0]\n", + "exact" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "dfee8d75-ec5d-480a-9ce5-8ef2e767ca88", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{0: -0.1651422047025889,\n", + " 1: 5.34339969152401,\n", + " 2: 0.21718192801878686,\n", + " 3: 0.023124310644335365,\n", + " 4: -0.08953620862239035,\n", + " 5: -187.77590163740436,\n", + " 6: -13.6239574744895,\n", + " 7: -0.7812618029815249,\n", + " 8: 0.35377243121702384,\n", + " 9: -2.5098083591119162,\n", + " 10: -0.047047117347459096,\n", + " 11: -0.7240011648957572,\n", + " 12: -0.4805793140773852,\n", + " 13: -1.0754630055859136,\n", + " 14: -0.7156602951529759,\n", + " 15: -0.26397350343646225}" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "{bs: (reconstructed[bs] - v0) / (sampled[bs] - v0) for bs, v0 in exact.items()}" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "c66a6675-9143-4b16-bae5-6aa541d83245", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{0: -0.0001982724463268637,\n", + " 1: -0.0002453634154370582,\n", + " 2: 2.7589470591220244e-05,\n", + " 3: -7.127812625152934e-06,\n", + " 4: -2.2142480258113828e-05,\n", + " 5: -3.591982021646889e-05,\n", + " 6: -3.415936542959606e-05,\n", + " 7: 0.00026998279666900354,\n", + " 8: 8.211637393075455e-05,\n", + " 9: 6.276849841074534e-05,\n", + " 10: -4.443388537950102e-06,\n", + " 11: 0.00013835150834172103,\n", + " 12: 8.13275019327167e-05,\n", + " 13: -0.0002124537180877114,\n", + " 14: 0.00024193773811832797,\n", + " 15: 0.0001791418922582888}" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "{bs: (reconstructed[bs] - v0) for bs, v0 in exact.items()}" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "476b77f0-53d3-4e45-be42-d2ae568dabdd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{0: 0.0012006164425619748,\n", + " 1: -4.59189709926186e-05,\n", + " 2: 0.0001270339150356639,\n", + " 3: -0.00030823892373626257,\n", + " 4: 0.0002473019641863264,\n", + " 5: 1.9129089464222163e-07,\n", + " 6: 2.5073012370714284e-06,\n", + " 7: -0.00034557275888654707,\n", + " 8: 0.0002321163739307311,\n", + " 9: -2.5009279367033295e-05,\n", + " 10: 9.444550035093871e-05,\n", + " 11: -0.00019109293610272172,\n", + " 12: -0.0001692280536228427,\n", + " 13: 0.00019754628191228794,\n", + " 14: -0.0003380622618816831,\n", + " 15: -0.0006786358855195018}" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "{bs: (sampled[bs] - v0) for bs, v0 in exact.items()}" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/test/cutting/test_cutting_decomposition.py b/test/cutting/test_cutting_decomposition.py index 1ce0d13e9..647c93b11 100644 --- a/test/cutting/test_cutting_decomposition.py +++ b/test/cutting/test_cutting_decomposition.py @@ -266,15 +266,6 @@ def test_cut_gates(self): qc.cx(0, 1) qpd_qc, _ = cut_gates(qc, [0]) self.assertEqual(qpd_qc, compare_qc) - with self.subTest("classical bit on input"): - qc = QuantumCircuit(2, 1) - qc.cx(0, 1) - with pytest.raises(ValueError) as e_info: - cut_gates(qc, [0]) - assert ( - e_info.value.args[0] - == "Circuits input to cut_gates should contain no classical registers or bits." - ) def test_unused_qubits(self): """Issue #218""" From ecfe07f33b02031c316148d6217dff3eb2430bca Mon Sep 17 00:00:00 2001 From: Jim Garrison Date: Mon, 2 Oct 2023 12:49:32 -0400 Subject: [PATCH 02/13] Fix lint --- .../04_reconstruct_distribution.ipynb | 21 +++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-) diff --git a/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb b/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb index f3649ae4f..d3e098aa8 100644 --- a/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb +++ b/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb @@ -12,19 +12,25 @@ "from qiskit.circuit import QuantumCircuit, ClassicalRegister\n", "from qiskit.circuit.library import EfficientSU2\n", "\n", - "from circuit_knitting.cutting import cut_gates, generate_cutting_experiments\n", - "from circuit_knitting.cutting.cutting_experiments import generate_distribution_cutting_experiments\n", + "from circuit_knitting.cutting import cut_gates\n", + "from circuit_knitting.cutting.cutting_experiments import (\n", + " generate_distribution_cutting_experiments,\n", + ")\n", "from circuit_knitting.cutting.cutting_reconstruction import reconstruct_distribution\n", "\n", "\n", - "def construct_circuit(num_qubits: int, num_measurements: int, reps: int = 1) -> tuple[QuantumCircuit, QuantumCircuit]:\n", - " circuit = EfficientSU2(num_qubits=num_qubits, reps=reps, entanglement=\"circular\").decompose()\n", + "def construct_circuit(\n", + " num_qubits: int, num_measurements: int, reps: int = 1\n", + ") -> tuple[QuantumCircuit, QuantumCircuit]:\n", + " circuit = EfficientSU2(\n", + " num_qubits=num_qubits, reps=reps, entanglement=\"circular\"\n", + " ).decompose()\n", " circuit.assign_parameters([0.4] * len(circuit.parameters), inplace=True)\n", "\n", " circuit.add_register(ClassicalRegister(num_measurements))\n", " for i in range(num_measurements):\n", " circuit.measure(i, i)\n", - " \n", + "\n", " cut_indices = [\n", " i\n", " for i, instruction in enumerate(circuit.data)\n", @@ -81,7 +87,9 @@ } ], "source": [ - "subexperiments, coefficients = generate_distribution_cutting_experiments(circuit1, np.inf)\n", + "subexperiments, coefficients = generate_distribution_cutting_experiments(\n", + " circuit1, np.inf\n", + ")\n", "coefficients" ] }, @@ -161,6 +169,7 @@ "from circuit_knitting.utils.simulation import ExactSampler\n", "from qiskit_aer.primitives import Sampler as AerSampler\n", "\n", + "\n", "def sampler_simulator(circuits, shots=None):\n", " if shots is None:\n", " sampler = ExactSampler()\n", From ba2b2e3720c09f84499de12f46835a60d317fa6d Mon Sep 17 00:00:00 2001 From: Jim Garrison Date: Mon, 2 Oct 2023 13:57:02 -0400 Subject: [PATCH 03/13] Add test --- test/cutting/test_cutting_roundtrip.py | 49 +++++++++++++++++++++++++- 1 file changed, 48 insertions(+), 1 deletion(-) diff --git a/test/cutting/test_cutting_roundtrip.py b/test/cutting/test_cutting_roundtrip.py index 867ff6fdc..f67aa3703 100644 --- a/test/cutting/test_cutting_roundtrip.py +++ b/test/cutting/test_cutting_roundtrip.py @@ -15,7 +15,8 @@ import logging import numpy as np -from qiskit import QuantumCircuit +from qiskit.circuit import QuantumCircuit, ClassicalRegister +from qiskit.circuit.library import EfficientSU2 from qiskit.circuit.library.standard_gates import ( RXXGate, RYYGate, @@ -46,9 +47,14 @@ from circuit_knitting.utils.simulation import ExactSampler from circuit_knitting.cutting import ( partition_problem, + cut_gates, generate_cutting_experiments, reconstruct_expectation_values, ) +from circuit_knitting.cutting.cutting_experiments import ( + generate_distribution_cutting_experiments, +) +from circuit_knitting.cutting.cutting_reconstruction import reconstruct_distribution from circuit_knitting.cutting.instructions import Move logger = logging.getLogger(__name__) @@ -179,3 +185,44 @@ def test_cutting_exact_reconstruction(example_circuit): logger.info("Max error: %f", np.max(np.abs(exact_expvals - simulated_expvals))) assert np.allclose(exact_expvals, simulated_expvals, atol=1e-8) + + +@pytest.fixture( + params=[ + (8, 4, 1, 0.4), + ] +) +def example_sampler_circuit(request): + num_qubits, num_measurements, reps, gate_param = request.param + + circuit0 = EfficientSU2( + num_qubits=num_qubits, reps=reps, entanglement="circular" + ).decompose() + circuit0.assign_parameters([gate_param] * len(circuit0.parameters), inplace=True) + + circuit0.add_register(ClassicalRegister(num_measurements)) + for i in range(num_measurements): + circuit0.measure(i, i) + + cut_indices = [ + i + for i, instruction in enumerate(circuit0.data) + if {circuit0.find_bit(q)[0] for q in instruction.qubits} == {0, num_qubits - 1} + ] + circuit1, bases = cut_gates(circuit0, cut_indices) + + return circuit0, circuit1, bases + + +def test_cutting_exact_distribution_reconstruction(example_sampler_circuit): + circuit0, circuit1, bases = example_sampler_circuit + subexperiments, coefficients = generate_distribution_cutting_experiments( + circuit1, np.inf + ) + subexperiment_results = ExactSampler().run(subexperiments).result() + reconstructed = reconstruct_distribution( + subexperiment_results, circuit1.num_clbits, coefficients + ) + exact = ExactSampler().run(circuit0).result().quasi_dists[0] + for k in range(2**circuit1.num_clbits): + assert reconstructed.get(k, 0.0) == pytest.approx(exact.get(k, 0.0)) From 67116489a0322c5cc307d4ff9545ed7214961907 Mon Sep 17 00:00:00 2001 From: Jim Garrison Date: Mon, 2 Oct 2023 14:47:25 -0400 Subject: [PATCH 04/13] Achieve 100% coverage --- test/cutting/test_cutting_experiments.py | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/test/cutting/test_cutting_experiments.py b/test/cutting/test_cutting_experiments.py index 46efeda66..49bfbaafb 100644 --- a/test/cutting/test_cutting_experiments.py +++ b/test/cutting/test_cutting_experiments.py @@ -27,7 +27,10 @@ from circuit_knitting.cutting import generate_cutting_experiments from circuit_knitting.cutting.qpd import WeightType from circuit_knitting.cutting import partition_problem -from circuit_knitting.cutting.cutting_experiments import _append_measurement_circuit +from circuit_knitting.cutting.cutting_experiments import ( + generate_distribution_cutting_experiments, + _append_measurement_circuit, +) class TestCuttingExperiments(unittest.TestCase): @@ -187,3 +190,14 @@ def test_append_measurement_circuit(self): e_info.value.args[0] == "Quantum circuit qubit count (2) does not match qubit count of observable(s) (1). Try providing `qubit_locations` explicitly." ) + + def test_generate_distribution_cutting_experiments(self): + with self.subTest("test bad num_samples"): + qc = QuantumCircuit(4, 1) + qc.measure(0, 0) + with pytest.raises(ValueError) as e_info: + generate_distribution_cutting_experiments(qc, 0) + assert e_info.value.args[0] == "num_samples must be at least 1." + with pytest.raises(ValueError) as e_info: + generate_distribution_cutting_experiments(qc, np.nan) + assert e_info.value.args[0] == "num_samples must be at least 1." From e891b11c090124be6bf37d81e8e611b7fffa0001 Mon Sep 17 00:00:00 2001 From: Jim Garrison Date: Mon, 2 Oct 2023 14:54:21 -0400 Subject: [PATCH 05/13] Add title to notebook --- .../tutorials/04_reconstruct_distribution.ipynb | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb b/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb index d3e098aa8..6d74315e4 100644 --- a/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb +++ b/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb @@ -1,5 +1,13 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "9dd1e7ab-757e-4115-9bba-ef14190ba88f", + "metadata": {}, + "source": [ + "# Reconstruct probability distributions using circuit cutting" + ] + }, { "cell_type": "code", "execution_count": 1, From 621b4df97a46469d64918a6143fee03d4a677325 Mon Sep 17 00:00:00 2001 From: Jim Garrison Date: Mon, 2 Oct 2023 15:26:54 -0400 Subject: [PATCH 06/13] Remove (admittedly incorrect) type annotation to help python3.8 --- .../circuit_cutting/tutorials/04_reconstruct_distribution.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb b/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb index 6d74315e4..d54306a75 100644 --- a/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb +++ b/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb @@ -29,7 +29,7 @@ "\n", "def construct_circuit(\n", " num_qubits: int, num_measurements: int, reps: int = 1\n", - ") -> tuple[QuantumCircuit, QuantumCircuit]:\n", + "):\n", " circuit = EfficientSU2(\n", " num_qubits=num_qubits, reps=reps, entanglement=\"circular\"\n", " ).decompose()\n", From fc379da089fb947feca436c794f56a8874bcaa47 Mon Sep 17 00:00:00 2001 From: Jim Garrison Date: Mon, 2 Oct 2023 15:28:49 -0400 Subject: [PATCH 07/13] Fix lint --- .../tutorials/04_reconstruct_distribution.ipynb | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb b/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb index d54306a75..0177067f4 100644 --- a/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb +++ b/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb @@ -17,7 +17,7 @@ "source": [ "import numpy as np\n", "\n", - "from qiskit.circuit import QuantumCircuit, ClassicalRegister\n", + "from qiskit.circuit import ClassicalRegister\n", "from qiskit.circuit.library import EfficientSU2\n", "\n", "from circuit_knitting.cutting import cut_gates\n", @@ -27,9 +27,7 @@ "from circuit_knitting.cutting.cutting_reconstruction import reconstruct_distribution\n", "\n", "\n", - "def construct_circuit(\n", - " num_qubits: int, num_measurements: int, reps: int = 1\n", - "):\n", + "def construct_circuit(num_qubits: int, num_measurements: int, reps: int = 1):\n", " circuit = EfficientSU2(\n", " num_qubits=num_qubits, reps=reps, entanglement=\"circular\"\n", " ).decompose()\n", From 267733d4d13992808b2cbf1653607c6e43b6323c Mon Sep 17 00:00:00 2001 From: Jim Garrison Date: Mon, 2 Oct 2023 22:06:36 -0400 Subject: [PATCH 08/13] Fix on Qiskit Aer 0.12.0 --- .../tutorials/04_reconstruct_distribution.ipynb | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb b/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb index 0177067f4..d7e98f19b 100644 --- a/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb +++ b/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb @@ -15,6 +15,7 @@ "metadata": {}, "outputs": [], "source": [ + "import math\n", "import numpy as np\n", "\n", "from qiskit.circuit import ClassicalRegister\n", @@ -393,7 +394,7 @@ } ], "source": [ - "results = sampler_simulator(subexperiments, shots * overhead)\n", + "results = sampler_simulator(subexperiments, math.ceil(shots * overhead))\n", "results.quasi_dists" ] }, From e709206344f763fc4f1923d2c4c50844d387d32e Mon Sep 17 00:00:00 2001 From: Jim Garrison Date: Sat, 18 May 2024 09:14:34 -0400 Subject: [PATCH 09/13] Update cutting_decomposition.py --- circuit_knitting/cutting/cutting_decomposition.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/circuit_knitting/cutting/cutting_decomposition.py b/circuit_knitting/cutting/cutting_decomposition.py index 712d90a5e..9db58cbfb 100644 --- a/circuit_knitting/cutting/cutting_decomposition.py +++ b/circuit_knitting/cutting/cutting_decomposition.py @@ -137,14 +137,11 @@ def cut_gates( Returns: A copy of the input circuit with the specified gates replaced with :class:`.TwoQubitQPDGate`\ s and a list of :class:`.QPDBasis` instances -- one for each decomposed gate. - - Raises: - ValueError: The input circuit should contain no classical bits or registers. """ - # Replace specified gates with TwoQubitQPDGates if not inplace: circuit = circuit.copy() + # Replace specified gates with TwoQubitQPDGates bases = [] for gate_id in gate_ids: gate = circuit.data[gate_id] From 2775785794d5c59c69209d7679ddf0a5df4d9cf3 Mon Sep 17 00:00:00 2001 From: Jim Garrison Date: Sat, 18 May 2024 16:41:41 -0400 Subject: [PATCH 10/13] Restore `EfficientSU2` import --- test/cutting/test_cutting_roundtrip.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/cutting/test_cutting_roundtrip.py b/test/cutting/test_cutting_roundtrip.py index 84327709a..7a790cb52 100644 --- a/test/cutting/test_cutting_roundtrip.py +++ b/test/cutting/test_cutting_roundtrip.py @@ -16,7 +16,7 @@ import numpy as np from qiskit.circuit import QuantumCircuit, ClassicalRegister -from qiskit.circuit.library import UnitaryGate +from qiskit.circuit.library import EfficientSU2, UnitaryGate from qiskit.circuit.library.standard_gates import ( RXXGate, RYYGate, From 9028f48cd903061539a6cc01bebfb9a48afd70ec Mon Sep 17 00:00:00 2001 From: Jim Garrison Date: Fri, 24 May 2024 16:31:09 -0400 Subject: [PATCH 11/13] Remove outdated comment --- circuit_knitting/cutting/cutting_reconstruction.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/circuit_knitting/cutting/cutting_reconstruction.py b/circuit_knitting/cutting/cutting_reconstruction.py index 02e9e5e11..9ae8dbe5c 100644 --- a/circuit_knitting/cutting/cutting_reconstruction.py +++ b/circuit_knitting/cutting/cutting_reconstruction.py @@ -40,8 +40,6 @@ def reconstruct_distribution( quasi_dists_out: dict[str | int, float] = {} for quasi_dist, (coeff, _) in strict_zip(results.quasi_dists, coefficients): for outcome, weight in quasi_dist.items(): - # NOTE: The registers are in the opposite order compared to - # cutting_reconstruction._process_outcome. meas_outcomes = outcome & ((1 << num_meas_bits) - 1) qpd_outcomes = outcome >> num_meas_bits qpd_factor = 1 - 2 * (bit_count(qpd_outcomes) & 1) From 7dad268b58cb0c3454fb9103ff069650a29ad52b Mon Sep 17 00:00:00 2001 From: Jim Garrison Date: Fri, 24 May 2024 17:01:40 -0400 Subject: [PATCH 12/13] Remove special `generate_distribution_cutting_experiments` function --- .../cutting/cutting_experiments.py | 108 +++++++----------- ...pynb => 05_reconstruct_distribution.ipynb} | 6 +- 2 files changed, 46 insertions(+), 68 deletions(-) rename docs/circuit_cutting/tutorials/{04_reconstruct_distribution.ipynb => 05_reconstruct_distribution.ipynb} (99%) diff --git a/circuit_knitting/cutting/cutting_experiments.py b/circuit_knitting/cutting/cutting_experiments.py index cea86ffc5..a669f9ef9 100644 --- a/circuit_knitting/cutting/cutting_experiments.py +++ b/circuit_knitting/cutting/cutting_experiments.py @@ -33,44 +33,6 @@ from .cutting_decomposition import decompose_observables -def generate_distribution_cutting_experiments( - circuit: QuantumCircuit, - num_samples: float, -): - """Generate cutting experiments for reconstructing a probability distribution.""" - # FIXME: make sure there's at least one measurement in the circuit - - if not num_samples >= 1: - raise ValueError("num_samples must be at least 1.") - - # Gather the unique bases from the circuit - bases, qpd_gate_ids = _get_bases(circuit) - - # Sample the joint quasiprobability decomposition - random_samples = generate_qpd_weights(bases, num_samples=num_samples) - - # Calculate terms in coefficient calculation - kappa = np.prod([basis.kappa for basis in bases]) - num_samples = sum([value[0] for value in random_samples.values()]) - - # Sort samples in descending order of frequency - sorted_samples = sorted(random_samples.items(), key=lambda x: x[1][0], reverse=True) - - # Generate the output experiments and their respective coefficients - subexperiments: list[QuantumCircuit] = [] - coefficients: list[tuple[float, WeightType]] = [] - for z, (map_ids, (redundancy, weight_type)) in enumerate(sorted_samples): - actual_coeff = np.prod( - [basis.coeffs[map_id] for basis, map_id in strict_zip(bases, map_ids)] - ) - sampled_coeff = (redundancy / num_samples) * (kappa * np.sign(actual_coeff)) - coefficients.append((sampled_coeff, weight_type)) - decomp_qc = decompose_qpd_instructions(circuit, qpd_gate_ids, map_ids) - subexperiments.append(decomp_qc) - - return subexperiments, coefficients - - def generate_cutting_experiments( circuits: QuantumCircuit | dict[Hashable, QuantumCircuit], observables: PauliList | dict[Hashable, PauliList], @@ -120,14 +82,21 @@ def generate_cutting_experiments( to the same cut. ValueError: :class:`SingleQubitQPDGate` instances are not allowed in unseparated circuits. """ - if isinstance(circuits, QuantumCircuit) and not isinstance(observables, PauliList): - raise ValueError( - "If the input circuits is a QuantumCircuit, the observables must be a PauliList." - ) - if isinstance(circuits, dict) and not isinstance(observables, dict): - raise ValueError( - "If the input circuits are contained in a dictionary keyed by partition labels, the input observables must also be represented by such a dictionary." - ) + if observables is None: + # FIXME: ensure there's at least one measurement in at least one of the subsystems. + # And it's kind of weird, because any subcircuit without measurements does not need to be run!! + pass + else: + if isinstance(circuits, QuantumCircuit) and not isinstance( + observables, PauliList + ): + raise ValueError( + "If the input circuits is a QuantumCircuit, the observables must be a PauliList." + ) + if isinstance(circuits, dict) and not isinstance(observables, dict): + raise ValueError( + "If the input circuits are contained in a dictionary keyed by partition labels, the input observables must also be represented by such a dictionary." + ) if not num_samples >= 1: raise ValueError("num_samples must be at least 1.") @@ -137,13 +106,16 @@ def generate_cutting_experiments( if isinstance(circuits, QuantumCircuit): is_separated = False subcircuit_dict: dict[Hashable, QuantumCircuit] = {"A": circuits} - subobservables_by_subsystem = decompose_observables( - observables, "A" * len(observables[0]) - ) - subsystem_observables = { - label: ObservableCollection(subobservables) - for label, subobservables in subobservables_by_subsystem.items() - } + if observables is None: + subsystem_observables = None + else: + subobservables_by_subsystem = decompose_observables( + observables, "A" * len(observables[0]) + ) + subsystem_observables = { + label: ObservableCollection(subobservables) + for label, subobservables in subobservables_by_subsystem.items() + } # Gather the unique bases from the circuit bases, qpd_gate_ids = _get_bases(circuits) subcirc_qpd_gate_ids: dict[Hashable, list[list[int]]] = {"A": qpd_gate_ids} @@ -158,10 +130,12 @@ def generate_cutting_experiments( bases = _get_bases_by_partition(subcircuit_dict, subcirc_qpd_gate_ids) # Create the commuting observable groups - subsystem_observables = { - label: ObservableCollection(so) for label, so in observables.items() - } - + if observables is None: + subsystem_observables = None + else: + subsystem_observables = { + label: ObservableCollection(so) for label, so in observables.items() + } # Sample the joint quasiprobability decomposition random_samples = generate_qpd_weights(bases, num_samples=num_samples) @@ -182,17 +156,23 @@ def generate_cutting_experiments( sampled_coeff = (redundancy / num_samples) * (kappa * np.sign(actual_coeff)) coefficients.append((sampled_coeff, weight_type)) map_ids_tmp = map_ids - for label, so in subsystem_observables.items(): - subcircuit = subcircuit_dict[label] + for label, subcircuit in subcircuit_dict.items(): if is_separated: map_ids_tmp = tuple(map_ids[j] for j in subcirc_map_ids[label]) - for j, cog in enumerate(so.groups): - new_qc = _append_measurement_register(subcircuit, cog) - decompose_qpd_instructions( - new_qc, subcirc_qpd_gate_ids[label], map_ids_tmp, inplace=True + if subsystem_observables is None: + new_qc = decompose_qpd_instructions( + subcircuit, subcirc_qpd_gate_ids[label], map_ids_tmp, inplace=False ) - _append_measurement_circuit(new_qc, cog, inplace=True) subexperiments_dict[label].append(new_qc) + else: + so = subsystem_observables[label] + for j, cog in enumerate(so.groups): + new_qc = _append_measurement_register(subcircuit, cog) + decompose_qpd_instructions( + new_qc, subcirc_qpd_gate_ids[label], map_ids_tmp, inplace=True + ) + _append_measurement_circuit(new_qc, cog, inplace=True) + subexperiments_dict[label].append(new_qc) # Remove initial and final resets from the subexperiments. This will # enable the `Move` operation to work on backends that don't support diff --git a/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb b/docs/circuit_cutting/tutorials/05_reconstruct_distribution.ipynb similarity index 99% rename from docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb rename to docs/circuit_cutting/tutorials/05_reconstruct_distribution.ipynb index d7e98f19b..5f618dfda 100644 --- a/docs/circuit_cutting/tutorials/04_reconstruct_distribution.ipynb +++ b/docs/circuit_cutting/tutorials/05_reconstruct_distribution.ipynb @@ -23,7 +23,7 @@ "\n", "from circuit_knitting.cutting import cut_gates\n", "from circuit_knitting.cutting.cutting_experiments import (\n", - " generate_distribution_cutting_experiments,\n", + " generate_cutting_experiments,\n", ")\n", "from circuit_knitting.cutting.cutting_reconstruction import reconstruct_distribution\n", "\n", @@ -94,9 +94,7 @@ } ], "source": [ - "subexperiments, coefficients = generate_distribution_cutting_experiments(\n", - " circuit1, np.inf\n", - ")\n", + "subexperiments, coefficients = generate_cutting_experiments(circuit1, None, np.inf)\n", "coefficients" ] }, From 5a47b361545a76f43722b4304a715572c6d2f584 Mon Sep 17 00:00:00 2001 From: Jim Garrison Date: Fri, 24 May 2024 20:37:06 -0400 Subject: [PATCH 13/13] Fix tests --- test/cutting/test_cutting_experiments.py | 12 ------------ test/cutting/test_cutting_roundtrip.py | 7 +------ 2 files changed, 1 insertion(+), 18 deletions(-) diff --git a/test/cutting/test_cutting_experiments.py b/test/cutting/test_cutting_experiments.py index c6603f984..47c6e15c0 100644 --- a/test/cutting/test_cutting_experiments.py +++ b/test/cutting/test_cutting_experiments.py @@ -28,7 +28,6 @@ from circuit_knitting.cutting.qpd import WeightType from circuit_knitting.cutting import partition_problem from circuit_knitting.cutting.cutting_experiments import ( - generate_distribution_cutting_experiments, _append_measurement_register, _append_measurement_circuit, _remove_final_resets, @@ -224,17 +223,6 @@ def test_append_measurement_circuit(self): == "Quantum circuit qubit count (2) does not match qubit count of observable(s) (1). Try providing `qubit_locations` explicitly." ) - def test_generate_distribution_cutting_experiments(self): - with self.subTest("test bad num_samples"): - qc = QuantumCircuit(4, 1) - qc.measure(0, 0) - with pytest.raises(ValueError) as e_info: - generate_distribution_cutting_experiments(qc, 0) - assert e_info.value.args[0] == "num_samples must be at least 1." - with pytest.raises(ValueError) as e_info: - generate_distribution_cutting_experiments(qc, np.nan) - assert e_info.value.args[0] == "num_samples must be at least 1." - def test_consolidate_double_reset(self): """Consolidate a pair of resets. qr0:--|0>--|0>-- ==> qr0:--|0>-- diff --git a/test/cutting/test_cutting_roundtrip.py b/test/cutting/test_cutting_roundtrip.py index 7a790cb52..033911183 100644 --- a/test/cutting/test_cutting_roundtrip.py +++ b/test/cutting/test_cutting_roundtrip.py @@ -51,9 +51,6 @@ generate_cutting_experiments, reconstruct_expectation_values, ) -from circuit_knitting.cutting.cutting_experiments import ( - generate_distribution_cutting_experiments, -) from circuit_knitting.cutting.cutting_reconstruction import reconstruct_distribution from circuit_knitting.cutting.instructions import Move @@ -260,9 +257,7 @@ def example_sampler_circuit(request): def test_cutting_exact_distribution_reconstruction(example_sampler_circuit): circuit0, circuit1, bases = example_sampler_circuit - subexperiments, coefficients = generate_distribution_cutting_experiments( - circuit1, np.inf - ) + subexperiments, coefficients = generate_cutting_experiments(circuit1, None, np.inf) subexperiment_results = ExactSampler().run(subexperiments).result() reconstructed = reconstruct_distribution( subexperiment_results, circuit1.num_clbits, coefficients