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)
