def test_circuit_sampler_caching(self, caching): """Test caching all operators works.""" try: from qiskit.providers.aer import Aer except Exception as ex: # pylint: disable=broad-except self.skipTest( "Aer doesn't appear to be installed. Error: '{}'".format( str(ex))) return x = Parameter('x') circuit = QuantumCircuit(1) circuit.ry(x, 0) expr1 = ~StateFn(H) @ StateFn(circuit) expr2 = ~StateFn(X) @ StateFn(circuit) sampler = CircuitSampler(Aer.get_backend('statevector_simulator'), caching=caching) res1 = sampler.convert(expr1, params={x: 0}).eval() res2 = sampler.convert(expr2, params={x: 0}).eval() res3 = sampler.convert(expr1, params={x: 0}).eval() res4 = sampler.convert(expr2, params={x: 0}).eval() self.assertEqual(res1, res3) self.assertEqual(res2, res4) if caching == 'last': self.assertEqual(len(sampler._cached_ops.keys()), 1) else: self.assertEqual(len(sampler._cached_ops.keys()), 2)
def test_vqe_expectation_select(self): """Test expectation selection with Aer's qasm_simulator.""" try: from qiskit.providers.aer import Aer except Exception as ex: # pylint: disable=broad-except self.skipTest( "Aer doesn't appear to be installed. Error: '{}'".format( str(ex))) return backend = Aer.get_backend('qasm_simulator') with self.subTest('Defaults'): vqe = VQE(quantum_instance=backend) vqe.compute_minimum_eigenvalue(operator=self.h2_op) self.assertIsInstance(vqe.expectation, PauliExpectation) with self.subTest('Include custom'): vqe = VQE(include_custom=True, quantum_instance=backend) vqe.compute_minimum_eigenvalue(operator=self.h2_op) self.assertIsInstance(vqe.expectation, AerPauliExpectation) with self.subTest('Set explicitly'): vqe = VQE(expectation=AerPauliExpectation(), quantum_instance=backend) vqe.compute_minimum_eigenvalue(operator=self.h2_op) self.assertIsInstance(vqe.expectation, AerPauliExpectation)
def test_with_aer_statevector(self): """Test VQE with Aer's statevector_simulator.""" try: # pylint: disable=import-outside-toplevel from qiskit.providers.aer import Aer except Exception as ex: # pylint: disable=broad-except self.skipTest( "Aer doesn't appear to be installed. Error: '{}'".format( str(ex))) return backend = Aer.get_backend('statevector_simulator') wavefunction = self.ry_wavefunction optimizer = L_BFGS_B() quantum_instance = QuantumInstance( backend, seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed) vqe = VQE(var_form=wavefunction, optimizer=optimizer, max_evals_grouped=1, quantum_instance=quantum_instance) result = vqe.compute_minimum_eigenvalue(operator=self.h2_op) self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy, places=6)
def test_with_aer_qasm_snapshot_mode(self): """Test the VQE using Aer's qasm_simulator snapshot mode.""" try: from qiskit.providers.aer import Aer except Exception as ex: # pylint: disable=broad-except self.skipTest( "Aer doesn't appear to be installed. Error: '{}'".format( str(ex))) return backend = Aer.get_backend('qasm_simulator') optimizer = L_BFGS_B() wavefunction = self.ry_wavefunction quantum_instance = QuantumInstance( backend, shots=1, seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed) vqe = VQE(var_form=wavefunction, optimizer=optimizer, expectation=AerPauliExpectation(), quantum_instance=quantum_instance) result = vqe.compute_minimum_eigenvalue(operator=self.h2_op) self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy, places=6)
def test_with_aer_qasm(self): """Test VQE with Aer's qasm_simulator.""" try: from qiskit.providers.aer import Aer except Exception as ex: # pylint: disable=broad-except self.skipTest( "Aer doesn't appear to be installed. Error: '{}'".format( str(ex))) return backend = Aer.get_backend('qasm_simulator') optimizer = SPSA(maxiter=200, last_avg=5) wavefunction = self.ry_wavefunction quantum_instance = QuantumInstance( backend, seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed) vqe = VQE(var_form=wavefunction, optimizer=optimizer, expectation=PauliExpectation(), quantum_instance=quantum_instance) result = vqe.compute_minimum_eigenvalue(operator=self.h2_op) self.assertAlmostEqual(result.eigenvalue.real, -1.86305, places=2)
def test_coefficients_correctly_propagated(self): """Test that the coefficients in SummedOp and states are correctly used.""" try: from qiskit.providers.aer import Aer except Exception as ex: # pylint: disable=broad-except self.skipTest( "Aer doesn't appear to be installed. Error: '{}'".format( str(ex))) return with self.subTest('zero coeff in SummedOp'): op = 0 * (I + Z) state = Plus self.assertEqual((~StateFn(op) @ state).eval(), 0j) backend = Aer.get_backend('qasm_simulator') q_instance = QuantumInstance(backend, seed_simulator=97, seed_transpiler=97) op = I with self.subTest('zero coeff in summed StateFn and CircuitSampler'): state = 0 * (Plus + Minus) sampler = CircuitSampler(q_instance).convert(~StateFn(op) @ state) self.assertEqual(sampler.eval(), 0j) with self.subTest( 'coeff gets squared in CircuitSampler shot-based readout'): state = (Plus + Minus) / numpy.sqrt(2) sampler = CircuitSampler(q_instance).convert(~StateFn(op) @ state) self.assertAlmostEqual(sampler.eval(), 1 + 0j)
def test_parameter_binding_on_listop(self): """Test passing a ListOp with differing parameters works with the circuit sampler.""" try: from qiskit.providers.aer import Aer except Exception as ex: # pylint: disable=broad-except self.skipTest( "Aer doesn't appear to be installed. Error: '{}'".format( str(ex))) return x, y = Parameter('x'), Parameter('y') circuit1 = QuantumCircuit(1) circuit1.p(0.2, 0) circuit2 = QuantumCircuit(1) circuit2.p(x, 0) circuit3 = QuantumCircuit(1) circuit3.p(y, 0) bindings = {x: -0.4, y: 0.4} listop = ListOp( [StateFn(circuit) for circuit in [circuit1, circuit2, circuit3]]) sampler = CircuitSampler(Aer.get_backend('qasm_simulator')) sampled = sampler.convert(listop, params=bindings) self.assertTrue(all(len(op.parameters) == 0 for op in sampled.oplist))
def test_ideal_tensored_meas_cal(self): """Test ideal execution, without noise.""" mit_pattern = [[1, 2], [3, 4, 5], [6]] meas_layout = [1, 2, 3, 4, 5, 6] # Generate the calibration circuits meas_calibs, _ = tensored_meas_cal(mit_pattern=mit_pattern) # Perform an ideal execution on the generated circuits backend = Aer.get_backend("qasm_simulator") cal_results = qiskit.execute(meas_calibs, backend=backend, shots=self.shots).result() # Make calibration matrices meas_cal = TensoredMeasFitter(cal_results, mit_pattern=mit_pattern) # Assert that the calibration matrices are equal to identity cal_matrices = meas_cal.cal_matrices self.assertEqual(len(mit_pattern), len(cal_matrices), "Wrong number of calibration matrices") for qubit_list, cal_mat in zip(mit_pattern, cal_matrices): IdentityMatrix = np.identity(2**len(qubit_list)) self.assertListEqual( cal_mat.tolist(), IdentityMatrix.tolist(), "Error: the calibration matrix is not equal to identity", ) # Assert that the readout fidelity is equal to 1 self.assertEqual( meas_cal.readout_fidelity(), 1.0, "Error: the average fidelity is not equal to 1", ) # Generate ideal (equally distributed) results results_dict, _ = self.generate_ideal_results(count_keys(6), 6) # Output the filter meas_filter = meas_cal.filter # Apply the calibration matrix to results # in list and dict forms using different methods results_dict_1 = meas_filter.apply(results_dict, method="least_squares", meas_layout=meas_layout) results_dict_0 = meas_filter.apply(results_dict, method="pseudo_inverse", meas_layout=meas_layout) # Assert that the results are equally distributed self.assertDictEqual(results_dict, results_dict_0) round_results = {} for key, val in results_dict_1.items(): round_results[key] = np.round(val) self.assertDictEqual(results_dict, round_results)
def test_meas_cal_on_circuit(self): """Test an execution on a circuit.""" # Generate the calibration circuits meas_calibs, state_labels, ghz = meas_calib_circ_creation() # Run the calibration circuits backend = Aer.get_backend("qasm_simulator") job = qiskit.execute( meas_calibs, backend=backend, shots=self.shots, seed_simulator=SEED, seed_transpiler=SEED, ) cal_results = job.result() # Make a calibration matrix meas_cal = CompleteMeasFitter(cal_results, state_labels) # Calculate the fidelity fidelity = meas_cal.readout_fidelity() job = qiskit.execute([ghz], backend=backend, shots=self.shots, seed_simulator=SEED, seed_transpiler=SEED) results = job.result() # Predicted equally distributed results predicted_results = {"000": 0.5, "111": 0.5} meas_filter = meas_cal.filter # Calculate the results after mitigation output_results_pseudo_inverse = meas_filter.apply( results, method="pseudo_inverse").get_counts(0) output_results_least_square = meas_filter.apply( results, method="least_squares").get_counts(0) # Compare with expected fidelity and expected results self.assertAlmostEqual(fidelity, 1.0) self.assertAlmostEqual(output_results_pseudo_inverse["000"] / self.shots, predicted_results["000"], places=1) self.assertAlmostEqual(output_results_least_square["000"] / self.shots, predicted_results["000"], places=1) self.assertAlmostEqual(output_results_pseudo_inverse["111"] / self.shots, predicted_results["111"], places=1) self.assertAlmostEqual(output_results_least_square["111"] / self.shots, predicted_results["111"], places=1)
def test_ideal_meas_cal(self): """Test ideal execution, without noise.""" for nq in self.nq_list: for pattern_type in range(1, 2**nq): # Generate the quantum register according to the pattern qubits, weight = self.choose_calibration(nq, pattern_type) # Generate the calibration circuits meas_calibs, state_labels = complete_meas_cal(qubit_list=qubits, circlabel="test") # Perform an ideal execution on the generated circuits backend = Aer.get_backend("qasm_simulator") job = qiskit.execute(meas_calibs, backend=backend, shots=self.shots) cal_results = job.result() # Make a calibration matrix meas_cal = CompleteMeasFitter(cal_results, state_labels, circlabel="test") # Assert that the calibration matrix is equal to identity IdentityMatrix = np.identity(2**weight) self.assertListEqual( meas_cal.cal_matrix.tolist(), IdentityMatrix.tolist(), "Error: the calibration matrix is not equal to identity", ) # Assert that the readout fidelity is equal to 1 self.assertEqual( meas_cal.readout_fidelity(), 1.0, "Error: the average fidelity is not equal to 1", ) # Generate ideal (equally distributed) results results_dict, results_list = self.generate_ideal_results(state_labels, weight) # Output the filter meas_filter = meas_cal.filter # Apply the calibration matrix to results # in list and dict forms using different methods results_dict_1 = meas_filter.apply(results_dict, method="least_squares") results_dict_0 = meas_filter.apply(results_dict, method="pseudo_inverse") results_list_1 = meas_filter.apply(results_list, method="least_squares") results_list_0 = meas_filter.apply(results_list, method="pseudo_inverse") # Assert that the results are equally distributed self.assertListEqual(results_list, results_list_0.tolist()) self.assertListEqual(results_list, np.round(results_list_1).tolist()) self.assertDictEqual(results_dict, results_dict_0) round_results = {} for key, val in results_dict_1.items(): round_results[key] = np.round(val) self.assertDictEqual(results_dict, round_results)
def test_unitary() -> None: qc = circuit_gen() b = AerUnitaryBackend() for comp in (None, b.default_compilation_pass()): tb = TketBackend(b, comp) job = execute(qc, tb) u = job.result().get_unitary() qb = Aer.get_backend("unitary_simulator") job2 = execute(qc, qb) u2 = job2.result().get_unitary() assert np.allclose(u, u2)
def test_is_measurement_correctly_propagated(self): """Test if is_measurement property of StateFn is propagated to converted StateFn.""" try: from qiskit.providers.aer import Aer except Exception as ex: # pylint: disable=broad-except self.skipTest("Aer doesn't appear to be installed. Error: '{}'".format(str(ex))) return backend = Aer.get_backend("aer_simulator") q_instance = QuantumInstance(backend) # no seeds needed since no values are compared state = Plus sampler = CircuitSampler(q_instance).convert(~state @ state) self.assertTrue(sampler.oplist[0].is_measurement)
def test_state() -> None: qc = circuit_gen() b = AerStateBackend() for comp in (None, b.default_compilation_pass()): tb = TketBackend(b, comp) assert QuantumInstance(tb).is_statevector job = execute(qc, tb) state = job.result().get_statevector() qb = Aer.get_backend("statevector_simulator") job2 = execute(qc, qb) state2 = job2.result().get_statevector() assert np.allclose(state, state2)
def create_quantum_computer_simulation(couplingmap, depolarizingnoise=False, depolarizingnoiseparameter=0, bitfliperror=False, bitfliperrorparameter=0, measerror=False, measerrorparameter=0): """ Returns a dictionary, where the key is what type of simulation ("noisy_qasm", "noiseless_qasm", "real"), and the value are the objects required for that particular simulation """ sims = ["noisy_qasm", "noiseless_qasm"] dicto = dict() for sim in sims: if sim == "noiseless_qasm": backend = Aer.get_backend('qasm_simulator') dicto[sim] = backend elif sim == "noisy_qasm": backend = Aer.get_backend('qasm_simulator') coupling_map = CouplingMap(couplingmap) noise_model = NoiseModel() if depolarizingnoise == True: depolarizingerror = depolarizing_error( depolarizingnoiseparameter, 1) noise_model.add_all_qubit_quantum_error( depolarizingerror, ['u1', 'u2', 'u3']) if bitfliperror == True: error_gate1 = pauli_error([('X', bitfliperrorparameter), ('I', 1 - bitfliperrorparameter)]) noise_model.add_all_qubit_quantum_error( error_gate1, ["u1", "u2", "u3"]) error_gate2 = error_gate1.tensor(error_gate1) noise_model.add_all_qubit_quantum_error(error_gate2, ["cx"]) if measerror == True: error_meas = pauli_error([('X', measerrorparameter), ('I', 1 - measerrorparameter)]) noise_model.add_all_qubit_quantum_error(error_meas, "measure") dicto[sim] = (backend, coupling_map, noise_model) return dicto
def create_backend(backend_name, token=''): """ Creates a quantum backend given the backend name. We allow two provider: aer, ibmq. We expect the backend_name to follow the format provider_instance i.e. ibmq_santiago, ibmq_16_melbourne, aer_qasm_simulator. """ backend_name = backend_name.lower() if 'aer' in backend_name: provider = 'aer' instance = backend_name[4:] elif 'ibmq' in backend_name: provider = 'ibmq' instance = backend_name else: raise Exception('Unknown backend name specified.') if 'ibmq' in provider: if token == '': raise Exception('A token is needed when using ibm backends.') else: return IBMQ.enable_account(token).get_backend(instance) elif 'aer' in provider: if 'qasm' in instance: return Aer.get_backend('qasm_simulator') elif 'vector' in instance: return Aer.get_backend('statevector_simulator') else: raise Exception('Backend provider ' + provider + ' does not have an instance called ' + instance + '.') else: raise Exception('Unknown backend provider.')
def choose_quantum_computer(hub, group, project, quantum_com): """ Returns a dictionary, where the key is what type of simulation ("noisy_qasm", "noiseless_qasm", "real"), and the value are the objects required for that particular simulation """ sims = ["noisy_qasm", "real", "noiseless_qasm"] dicto = dict() for sim in sims: if sim == "noisy_qasm": backend = Aer.get_backend('qasm_simulator') provider = IBMQ.get_provider(hub=hub, group=group, project=project) noisebackend = provider.get_backend(quantum_com) noisebackend = provider.get_backend(quantum_com) coupling_map = noisebackend.configuration().coupling_map # noise_model = NoiseModel.from_backend(noisebackend,gate_error=False,readout_error=False,thermal_relaxation=True) noise_model = NoiseModel.from_backend(noisebackend) dicto[sim] = (backend, coupling_map, noise_model) elif sim == "real": provider = IBMQ.get_provider(hub=hub, group=group, project=project) backend = provider.get_backend(quantum_com) dicto[sim] = backend elif sim == "noiseless_qasm": backend = Aer.get_backend('qasm_simulator') dicto[sim] = backend return dicto
def get_statevector(self): if self.method == "random_numbers" and self.statevector_evaluatedbefore == False: dimension = 2**self.N #np.random.seed(self.numpyseed) state = self.rand_generator.random( dimension) + 1j * self.rand_generator.random(dimension) #state = np.random.rand(dimension) + 1j * np.random.rand(dimension) state = state / np.sqrt(np.vdot(state, state)) self.statevector = state self.statevector_evaluatedbefore = True return state elif self.method == "random_numbers" and self.statevector_evaluatedbefore == True: return self.statevector elif self.method == "efficient_SU2" or "own_qiskit_circuit": statevector_backend = Aer.get_backend('statevector_simulator') state = execute(self.qiskit_circuit, statevector_backend).result().get_statevector() return state
def test_single_parameter_binds(self): """Test passing parameter binds as a dictionary to the circuit sampler.""" try: from qiskit.providers.aer import Aer except Exception as ex: # pylint: disable=broad-except self.skipTest("Aer doesn't appear to be installed. Error: '{}'".format(str(ex))) return x = Parameter("x") circuit = QuantumCircuit(1) circuit.ry(x, 0) expr = ~StateFn(H) @ StateFn(circuit) sampler = CircuitSampler(Aer.get_backend("aer_simulator_statevector")) res = sampler.convert(expr, params={x: 0}).eval() self.assertIsInstance(res, complex)
import numpy as np import pandas as pd import scipy import math import datetime import time from qiskit.aqua import aqua_globals, QuantumInstance import warnings warnings.simplefilter("ignore") starttime = datetime.datetime.now() backend = Aer.get_backend('statevector_simulator') shots = 1 #doesn't matter for statevector simulator qi = QuantumInstance(backend, shots) output_to_file = 1 output_to_cmd = 1 store_in_df = 1 output_to_csv = 1 enable_adapt = 1 enable_roto_2 = 0 num_optimizer_runs = 100000 print('num available cpus', len(psutil.Process().cpu_affinity())) print(starttime)
def _make_syndrome_graph(self): """ This method injects all possible Pauli errors into the circuit for ``code``. This is done by examining the qubits used in each gate of the circuit for a stored logical 0. A graph is then created with a node for each non-trivial syndrome element, and an edge between all such elements that can be created by the same error. """ S = rx.PyGraph(multigraph=False) qc = self.code.circuit['0'] blank_qc = QuantumCircuit() for qreg in qc.qregs: blank_qc.add_register(qreg) for creg in qc.cregs: blank_qc.add_register(creg) error_circuit = {} circuit_name = {} depth = len(qc) for j in range(depth): qubits = qc.data[j][1] for qubit in qubits: for error in ['x', 'y', 'z']: temp_qc = copy.deepcopy(blank_qc) temp_qc.name = str((j, qubit, error)) temp_qc.data = qc.data[0:j] getattr(temp_qc, error)(qubit) temp_qc.data += qc.data[j:depth + 1] circuit_name[(j, qubit, error)] = temp_qc.name error_circuit[temp_qc.name] = temp_qc if HAS_AER: simulator = Aer.get_backend('qasm_simulator') else: simulator = BasicAer.get_backend('qasm_simulator') job = execute(list(error_circuit.values()), simulator) node_map = {} for j in range(depth): qubits = qc.data[j][1] for qubit in qubits: for error in ['x', 'y', 'z']: raw_results = {} raw_results['0'] = job.result().get_counts( str((j, qubit, error))) results = self.code.process_results(raw_results)['0'] for string in results: nodes = self._string2nodes(string) assert len(nodes) in [0, 2], "Error of type " + \ error + " on qubit " + str(qubit) + \ " at depth " + str(j) + " creates " + \ str(len(nodes)) + \ " nodes in syndrome graph, instead of 2." for node in nodes: if node not in node_map: node_map[node] = S.add_node(node) for source in nodes: for target in nodes: if target != source: S.add_edge(node_map[source], node_map[target], 1) return S
def _make_syndrome_graph(self, results=None): S = rx.PyGraph(multigraph=False) if results: node_map = {} for string in results: nodes = self._string2nodes(string) for node in nodes: if node not in node_map: node_map[node] = S.add_node(node) for source in nodes: for target in nodes: if target != source: S.add_edge(node_map[source], node_map[target], 1) else: qc = self.code.circuit["0"] blank_qc = QuantumCircuit() for qreg in qc.qregs: blank_qc.add_register(qreg) for creg in qc.cregs: blank_qc.add_register(creg) error_circuit = {} circuit_name = {} depth = len(qc) for j in range(depth): qubits = qc.data[j][1] for qubit in qubits: for error in ["x", "y", "z"]: temp_qc = copy.deepcopy(blank_qc) temp_qc.name = str((j, qubit, error)) temp_qc.data = qc.data[0:j] getattr(temp_qc, error)(qubit) temp_qc.data += qc.data[j:depth + 1] circuit_name[(j, qubit, error)] = temp_qc.name error_circuit[temp_qc.name] = temp_qc if HAS_AER: simulator = Aer.get_backend("qasm_simulator") else: simulator = BasicAer.get_backend("qasm_simulator") job = execute(list(error_circuit.values()), simulator) node_map = {} for j in range(depth): qubits = qc.data[j][1] for qubit in qubits: for error in ["x", "y", "z"]: raw_results = {} raw_results["0"] = job.result().get_counts( str((j, qubit, error))) results = self.code.process_results(raw_results)["0"] for string in results: nodes = self._string2nodes(string) assert len(nodes) in [ 0, 2 ], ("Error of type " + error + " on qubit " + str(qubit) + " at depth " + str(j) + " creates " + str(len(nodes)) + " nodes in syndrome graph, instead of 2.") for node in nodes: if node not in node_map: node_map[node] = S.add_node(node) for source in nodes: for target in nodes: if target != source: S.add_edge(node_map[source], node_map[target], 1) return S
backend = TketBackend(qulacs, qulacs.default_compilation_pass()) grover_optimizer = GroverOptimizer(6, num_iterations=10, quantum_instance=backend) results = grover_optimizer.solve(qp) print("x={}".format(results.x)) print("fval={}".format(results.fval)) # Adding extra backends to target is nice, but where `pytket` really shines is in its compiler passes. The ability to exploit a large number of sources of redundancy in the circuit structure to reduce the execution cost on a noisy device is paramount in the NISQ era. We can examine the effects of this by looking at how effectively the algorithm works on the `qasm_simulator` from Qiskit Aer with a given noise model. # # (Note: some versions of `qiskit-aqua` give an `AssertionError` when the `solve()` step below is run. If you encounter this, try updating `qiskit-aqua` or, as a workaround, reducing the number of iterations to 2.) from qiskit.providers.aer import Aer from qiskit.providers.aer.noise import NoiseModel, depolarizing_error from qiskit.aqua import QuantumInstance backend = Aer.get_backend("qasm_simulator") model = NoiseModel() model.add_all_qubit_quantum_error(depolarizing_error(0.01, 1), ["p", "u"]) model.add_all_qubit_quantum_error(depolarizing_error(0.05, 2), ["cx"]) qi = QuantumInstance(backend, noise_model=model, seed_transpiler=2, seed_simulator=2) grover_optimizer = GroverOptimizer(6, num_iterations=10, quantum_instance=qi) results = grover_optimizer.solve(qp) print("x={}".format(results.x)) print("fval={}".format(results.fval)) print("n_circs={}".format(len(results.operation_counts))) # We can insert compilation passes from `pytket` into Qiskit as `TranspilerPass`es, compose with others to form a `PassManager`, and embed into the `QuantumInstance`. from pytket.passes import FullPeepholeOptimise
from qiskit.providers.aer import Aer as QiskitAer from shor.providers.qiskit.base import QiskitProvider DEFAULT_BACKEND = QiskitAer.get_backend("qasm_simulator") class Aer(QiskitProvider): def __init__(self, **config): config["backend"] = config.get("backend", DEFAULT_BACKEND) config["provider"] = QiskitAer super().__init__(**config)