def run(self, qobj): """Main job in simulator""" if HAS_AER: if qobj.type == 'PULSE': from qiskit.providers.aer.pulse import PulseSystemModel system_model = PulseSystemModel.from_backend(self) sim = Aer.get_backend('pulse_simulator') job = sim.run(qobj, system_model) else: sim = Aer.get_backend('qasm_simulator') if self.properties(): from qiskit.providers.aer.noise import NoiseModel noise_model = NoiseModel.from_backend(self, warnings=False) job = sim.run(qobj, noise_model=noise_model) else: job = sim.run(qobj) else: if qobj.type == 'PULSE': raise QiskitError("Unable to run pulse schedules without " "qiskit-aer installed") warnings.warn("Aer not found using BasicAer and no noise", RuntimeWarning) sim = BasicAer.get_backend('qasm_simulator') job = sim.run(qobj) return job
def evaluate_circuit(num_qubits,initial_state_object,paulistring_object,sim,shots,whichrealcomputer=None,noisebackend=None): if sim == 'noiseless': backend = Aer.get_backend("qasm_simulator") initial_state_circuit = initial_state_object.get_qiskit_circuit() paulistring_circuit = paulistring_object.get_qiskit_circuit() qc = QuantumCircuit(num_qubits) qc.append(initial_state_circuit,range(num_qubits)) qc.append(paulistring_circuit,range(num_qubits)) qc.measure_all() if sim == 'noiseless': counts = execute(qc,backend=backend,shots=shots).result().get_counts() newcountdict = {} #Need to reverse the strings (some qiskit thing) for key in counts.keys(): newkey = key[::-1] newcountdict[newkey] = counts[key] result = 0 for key in newcountdict.keys(): subresult = 1 for i in range(paulistring_object.get_N()): if int(paulistring_object.return_string()[i]) == 0: subresult = subresult else: if key[i] == '0': subresult = subresult elif key[i] == '1': subresult = subresult*-1 result = result + subresult*newcountdict[key] return result/sum(newcountdict.values())
def test_tensored_meas_cal_on_circuit(self): """Test an execution on a circuit.""" # Generate the calibration circuits meas_calibs, mit_pattern, ghz, meas_layout = tensored_calib_circ_creation( ) # Run the calibration circuits backend = Aer.get_backend("qasm_simulator") cal_results = qiskit.execute( meas_calibs, backend=backend, shots=self.shots, seed_simulator=SEED, seed_transpiler=SEED, ).result() # Make a calibration matrix meas_cal = TensoredMeasFitter(cal_results, mit_pattern=mit_pattern) # Calculate the fidelity fidelity = meas_cal.readout_fidelity(0) * meas_cal.readout_fidelity(1) results = qiskit.execute([ghz], backend=backend, shots=self.shots, seed_simulator=SEED, seed_transpiler=SEED).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", meas_layout=meas_layout).get_counts(0) output_results_least_square = meas_filter.apply( results, method="least_squares", meas_layout=meas_layout).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 simulate_circuit(circuit: QuantumCircuit): simulator = Aer.get_backend('qasm_simulator') job = execute(circuit, simulator, shots=1000) result = job.result() counts = result.get_counts(circuit) figure = plot_histogram(counts) figure.savefig("./test/results/plot.pdf")
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_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_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 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 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)
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
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)
def simulate(self, simulator=Aer(), shots=1000): compiled_circuit = transpile(self.circuit, simulator) job = simulator.run(compiled_circuit, shots=shots) result = job.result() self.counts = result.get_counts(self.circuit) return self.counts
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