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
