def hobo_qubo_mixer_measurement(hamildict,
noise_model,
angles,
diag_vals,
ps_end=False,
mid_measure=None):
n = int(np.max(hamildict[:, 1]))
qr = QuantumRegister(n**2)
main_circuit = QuantumCircuit(qr)
times = len(angles)
qubo_theta = angles[0:int(times / 2)]
mixer_phi = angles[int(times / 2):]
main_circuit += hadamards_position(n, qr)
# Merging circuits
for theta, phi in zip(qubo_theta, mixer_phi):
main_circuit += hobo2qubo(n, qr) + qubo_circuit_simplified(
hamildict, qr, theta) + hobo2qubo(n, qr).inverse()
main_circuit += make_mixer(n, qr, phi)
if mid_measure == 'no-ps':
main_circuit += kraus_gates(qr, n, False)
elif mid_measure == 'ps':
main_circuit += kraus_gates(qr, n, True)
else:
pass
if ps_end == 'end':
main_circuit += kraus_gates(qr, n, True)
main_circuit += hobo2qubo(n, qr)
# Swap all
for i in range(int(n**2 / 2)):
main_circuit.swap(i, n**2 - 1 - i)
#Preparation of Density-Matrix:
backend = QasmSimulator(method='density_matrix',
noise_model=noise_model,
basis_gates=['cx', 'u1', 'u2', 'u3', 'kraus'])
main_circuit.append(Snapshot('ss', 'density_matrix', n**2), qr)
job = execute(main_circuit, backend=backend)
result = job.result().results[0].to_dict(
)['data']['snapshots']['density_matrix']['ss'][0]['value']
dm = np.asmatrix(result)
#finds probability
prob = np.trace(dm.real)
#find mean energy
mean_energy = np.real(np.sum(np.diag(dm) * diag_vals)) / prob
max_energy = max(diag_vals)
min_energy = min(diag_vals)
energy = (mean_energy - min_energy) / (max_energy - min_energy)
return energy, prob
def test_y_gate_deterministic_waltz_basis_gates(self):
shots = 100
"""Test y-gate gate circuits compiling to u1,u2,u3,cx"""
circuits = ref_1q_clifford.y_gate_circuits_deterministic(final_measure=True)
targets = ref_1q_clifford.y_gate_counts_deterministic(shots)
job = execute(circuits, QasmSimulator(), shots=shots, basis_gates='u1,u2,u3,cx')
result = job.result()
self.is_completed(result)
self.compare_counts(result, circuits, targets, delta=0)
def test_conditional_2bit(self):
"""Test conditional operations on 2-bit conditional register."""
shots = 100
circuits = ref_conditionals.conditional_circuits_2bit(final_measure=True)
targets = ref_conditionals.conditional_counts_2bit(shots)
job = execute(circuits, QasmSimulator(), shots=shots)
result = job.result()
self.is_completed(result)
self.compare_counts(result, circuits, targets, delta=0)
def test_sdg_gate_nondeterministic_default_basis_gates(self):
shots = 2000
"""Test sdg-gate circuits compiling to backend default basis_gates."""
circuits = ref_1q_clifford.sdg_gate_circuits_nondeterministic(final_measure=True)
targets = ref_1q_clifford.sdg_gate_counts_nondeterministic(shots)
job = execute(circuits, QasmSimulator(), shots=shots)
result = job.result()
self.is_completed(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
def test_cx_gate_nondeterministic_waltz_basis_gates(self):
"""Test cx-gate gate circuits compiling to u1,u2,u3,cx"""
shots = 2000
circuits = ref_2q_clifford.cx_gate_circuits_nondeterministic(final_measure=True)
targets = ref_2q_clifford.cx_gate_counts_nondeterministic(shots)
job = execute(circuits, QasmSimulator(), shots=shots, basis_gates='u1,u2,u3,cx')
result = job.result()
self.is_completed(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
def test_cz_gate_deterministic_minimal_basis_gates(self):
"""Test cz-gate gate circuits compiling to U,CX"""
shots = 100
circuits = ref_2q_clifford.cz_gate_circuits_deterministic(final_measure=True)
targets = ref_2q_clifford.cz_gate_counts_deterministic(shots)
job = execute(circuits, QasmSimulator(), shots=shots, basis_gates='U,CX')
result = job.result()
self.is_completed(result)
self.compare_counts(result, circuits, targets, delta=0)
class QasmResetTests:
"""QasmSimulator reset tests."""
SIMULATOR = QasmSimulator()
BACKEND_OPTS = {}
# ---------------------------------------------------------------------
# Test reset
# ---------------------------------------------------------------------
def test_reset_deterministic(self):
"""Test QasmSimulator reset with for circuits with deterministic counts"""
# For statevector output we can combine deterministic and non-deterministic
# count output circuits
shots = 100
circuits = ref_reset.reset_circuits_deterministic(final_measure=True)
targets = ref_reset.reset_counts_deterministic(shots)
qobj = assemble(circuits, self.SIMULATOR, shots=shots)
result = self.SIMULATOR.run(
qobj, backend_options=self.BACKEND_OPTS).result()
self.assertTrue(getattr(result, 'success', False))
self.compare_counts(result, circuits, targets, delta=0)
def test_reset_nondeterministic(self):
"""Test QasmSimulator reset with for circuits with non-deterministic counts"""
# For statevector output we can combine deterministic and non-deterministic
# count output circuits
shots = 4000
circuits = ref_reset.reset_circuits_nondeterministic(
final_measure=True)
targets = ref_reset.reset_counts_nondeterministic(shots)
qobj = assemble(circuits, self.SIMULATOR, shots=shots)
result = self.SIMULATOR.run(
qobj, backend_options=self.BACKEND_OPTS).result()
self.assertTrue(getattr(result, 'success', False))
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
def test_reset_sampling_opt(self):
"""Test sampling optimization"""
shots = 4000
circuits = ref_reset.reset_circuits_sampling_optimization()
targets = ref_reset.reset_counts_sampling_optimization(shots)
qobj = assemble(circuits, self.SIMULATOR, shots=shots)
result = self.SIMULATOR.run(
qobj, backend_options=self.BACKEND_OPTS).result()
self.assertTrue(getattr(result, 'success', False))
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
def test_repeated_resets(self):
"""Test repeated reset operations"""
shots = 100
circuits = ref_reset.reset_circuits_repeated()
targets = ref_reset.reset_counts_repeated(shots)
qobj = assemble(circuits, self.SIMULATOR, shots=shots)
result = self.SIMULATOR.run(
qobj, backend_options=self.BACKEND_OPTS).result()
self.assertTrue(getattr(result, 'success', False))
self.compare_counts(result, circuits, targets, delta=0)
def test_cx_gate_deterministic_default_basis_gates(self):
"""Test cx-gate circuits compiling to backend default basis_gates."""
shots = 100
circuits = ref_2q_clifford.cx_gate_circuits_deterministic(final_measure=True)
targets = ref_2q_clifford.cx_gate_counts_deterministic(shots)
job = execute(circuits, QasmSimulator(), shots=shots)
result = job.result()
self.is_completed(result)
self.compare_counts(result, circuits, targets, delta=0)
class QasmStandardGateDensityMatrixTests:
"""QasmSimulator standard gate library tests."""
SIMULATOR = QasmSimulator()
BACKEND_OPTS = {}
SEED = 9997
RNG = default_rng(seed=SEED)
@data(*[(gate_params[0], gate_params[1], gate_params[2], basis_gates)
for gate_params, basis_gates in product(GATES, BASIS_GATES)])
@unpack
def test_gate_density_matrix(self, gate_cls, num_angles, has_ctrl_qubits,
basis_gates):
"""Test standard gate simulation test."""
SUPPORTED_METHODS = [
'automatic', 'statevector', 'statevector_gpu',
'statevector_thrust', 'density_matrix', 'density_matrix_gpu',
'density_matrix_thrust'
]
backend_options = self.BACKEND_OPTS.copy()
method = backend_options.pop('method', 'automatic')
backend = self.SIMULATOR
backend.set_options(method=method)
circuits = self.gate_circuits(gate_cls,
num_angles=num_angles,
has_ctrl_qubits=has_ctrl_qubits,
rng=self.RNG)
for circuit in circuits:
target = Statevector.from_instruction(circuit)
# Add snapshot and execute
circuit.snapshot_density_matrix('final')
result = execute(circuit,
backend,
shots=1,
basis_gates=basis_gates,
optimization_level=0,
**backend_options).result()
# Check results
success = getattr(result, 'success', False)
msg = '{}, method = {}'.format(gate_cls.__name__, method)
if method not in SUPPORTED_METHODS:
self.assertFalse(success)
else:
self.assertTrue(success, msg=msg)
self.assertSuccess(result)
snapshots = result.data(0).get("snapshots",
{}).get("density_matrix", {})
value = snapshots.get('final', [{'value': None}])[0]['value']
fidelity = state_fidelity(target, value)
self.assertGreater(fidelity, 0.99999, msg=msg)
class QasmSaveStateTests:
"""QasmSimulator SaveState instruction tests."""
SIMULATOR = QasmSimulator()
BACKEND_OPTS = {}
def test_save_state(self):
"""Test save_amplitudes instruction"""
REFERENCE_SAVE = {
'automatic': SaveStabilizer,
'stabilizer': SaveStabilizer,
'statevector': SaveStatevector,
'statevector_gpu': SaveStatevector,
'statevector_thrust': SaveStatevector,
'density_matrix': SaveDensityMatrix,
'density_matrix_gpu': SaveDensityMatrix,
'density_matrix_thrust': SaveDensityMatrix
}
REFERENCE_LABEL = {
'automatic': 'stabilizer',
'stabilizer': 'stabilizer',
'statevector': 'statevector',
'statevector_gpu': 'statevector',
'statevector_thrust': 'statevector',
'density_matrix': 'density_matrix',
'density_matrix_gpu': 'density_matrix',
'density_matrix_thrust': 'density_matrix'
}
opts = self.BACKEND_OPTS.copy()
method = opts.get('method', 'automatic')
if method in REFERENCE_SAVE:
# Stabilizer test circuit
num_qubits = 4
target_instr = REFERENCE_SAVE[method](num_qubits, label='target')
circ = QuantumCircuit(num_qubits)
circ.h(0)
for i in range(1, num_qubits):
circ.cx(i - 1, i)
circ.save_state()
circ.append(target_instr, range(num_qubits))
label = REFERENCE_LABEL[method]
# Run
qobj = assemble(circ, self.SIMULATOR)
result = self.SIMULATOR.run(qobj, **opts).result()
self.assertTrue(result.success)
data = result.data(0)
self.assertIn(label, data)
self.assertIn('target', data)
value = data[label]
target = data['target']
self.assertTrue(np.all(value == target))
class QasmPauliNoiseTests:
"""QasmSimulator pauli error noise model tests."""
SIMULATOR = QasmSimulator()
BACKEND_OPTS = {}
def test_pauli_gate_noise(self):
"""Test simulation with Pauli gate error noise model."""
shots = 1000
circuits = ref_pauli_noise.pauli_gate_error_circuits()
noise_models = ref_pauli_noise.pauli_gate_error_noise_models()
targets = ref_pauli_noise.pauli_gate_error_counts(shots)
for circuit, noise_model, target in zip(circuits, noise_models,
targets):
qobj = assemble(circuit, self.SIMULATOR, shots=shots)
result = self.SIMULATOR.run(qobj,
noise_model=noise_model,
**self.BACKEND_OPTS).result()
self.assertSuccess(result)
self.compare_counts(result, [circuit], [target],
delta=0.05 * shots)
def test_pauli_reset_noise(self):
"""Test simulation with Pauli reset error noise model."""
shots = 1000
circuits = ref_pauli_noise.pauli_reset_error_circuits()
noise_models = ref_pauli_noise.pauli_reset_error_noise_models()
targets = ref_pauli_noise.pauli_reset_error_counts(shots)
for circuit, noise_model, target in zip(circuits, noise_models,
targets):
qobj = assemble(circuit, self.SIMULATOR, shots=shots)
result = self.SIMULATOR.run(qobj,
noise_model=noise_model,
**self.BACKEND_OPTS).result()
self.assertSuccess(result)
self.compare_counts(result, [circuit], [target],
delta=0.05 * shots)
def test_pauli_measure_noise(self):
"""Test simulation with Pauli measure error noise model."""
shots = 1000
circuits = ref_pauli_noise.pauli_measure_error_circuits()
noise_models = ref_pauli_noise.pauli_measure_error_noise_models()
targets = ref_pauli_noise.pauli_measure_error_counts(shots)
for circuit, noise_model, target in zip(circuits, noise_models,
targets):
qobj = assemble(circuit, self.SIMULATOR, shots=shots)
result = self.SIMULATOR.run(qobj,
noise_model=noise_model,
**self.BACKEND_OPTS).result()
self.assertSuccess(result)
self.compare_counts(result, [circuit], [target],
delta=0.05 * shots)
class QuantumVolumeTimeSuite:
"""
Benchmarking times for Quantum Volume with various noise configurations
- ideal (no noise)
- mixed state
- reset
- kraus
For each noise model, we want to test various configurations of number of
qubits
The methods defined in this class will be executed by ASV framework as many
times as the combination of all parameters exist in `self.params`, for
exmaple: self.params = ([1,2,3],[4,5,6]), will run all methdos 9 times:
time_method(1,4)
time_method(1,5)
time_method(1,6)
time_method(2,4)
time_method(2,5)
time_method(2,6)
time_method(3,4)
time_method(3,5)
time_method(3,6)
"""
def __init__(self):
self.timeout = 60 * 20
self.qv_circuits = []
self.backend = QasmSimulator()
for num_qubits in (16, ):
for depth in (10, ):
# We want always the same seed, as we want always the same circuits
# for the same value pairs of qubits,depth
circ = quantum_volume_circuit(num_qubits, depth, seed=1)
self.qv_circuits.append(
Terra.compile(circ,
self.backend,
shots=1,
basis_gates=['u3', 'cx']))
self.param_names = ["Quantum Volume (16qubits 10depth)", "Noise Model"]
# This will run every benchmark for one of the combinations we have here:
# bench(qv_circuits, None) => bench(qv_circuits, mixed()) =>
# bench(qv_circuits, reset) => bench(qv_circuits, kraus())
self.params = (self.qv_circuits, [
None,
mixed_unitary_noise_model(),
reset_noise_model(),
kraus_noise_model()
])
def setup(self, qobj):
pass
def time_quantum_volume(self, qobj, noise_model):
result = self.backend.run(qobj, noise_model=noise_model).result()
if result.status != 'COMPLETED':
raise QiskitError("Simulation failed. Status: " + result.status)
def set_qasm(sim_opts):
sim_method = [opt for opt in sim_opts if opt.startswith('method')]
if len(sim_method) == 0:
backend = QasmSimulator(method='automatic',
max_memory_mb=2048)
sim_method = 'automatic'
else:
sim_method = sim_method[0].split('=')[1].strip('\n')
if sim_method not in qasm_methods:
print('SimulationError: simulation method not available. Available options: "statevector", "density_matrix", "matrix_product_state", "automatic"')
sys.exit()
else:
backend = QasmSimulator(method=sim_method,
max_memory_mb=2048)
return backend, sim_method
def __init__(self,ising,p,qubits,useNoiseModel = False):
self.ising = ising
self.p = p
self.useNoiseModel = useNoiseModel
self.qubits = qubits
self.register = None
self.q = QuantumRegister(qubits)
self.c = ClassicalRegister(qubits)
self.register = QuantumCircuit(self.q, self.c)
self.backend = QasmSimulator()
def test_grovers_minimal_basis_gates(self):
"""Test grovers circuits compiling to U,CX"""
shots = 2000
circuits = ref_algorithms.grovers_circuit(final_measure=True,
allow_sampling=True)
targets = ref_algorithms.grovers_counts(shots)
job = execute(circuits, QasmSimulator(), shots=shots, basis_gates='U,CX')
result = job.result()
self.is_completed(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
def test_reset_nondeterministic(self):
"""Test QasmSimulator reset with for circuits with non-deterministic counts"""
# For statevector output we can combine deterministic and non-deterministic
# count output circuits
shots = 2000
circuits = ref_reset.reset_circuits_nondeterministic(final_measure=True)
targets = ref_reset.reset_counts_nondeterministic(shots)
job = execute(circuits, QasmSimulator(), shots=shots)
result = job.result()
self.is_completed(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
class QuantumFourierTransformFusionSuite:
def __init__(self):
self.timeout = 60 * 20
self.backend = QasmSimulator()
num_qubits = [5, 10, 15, 20, 25]
self.circuit = {}
for num_qubit in num_qubits:
for use_cu1 in [True, False]:
circuit = self.qft_circuit(num_qubit, use_cu1)
self.circuit[(num_qubit, use_cu1)] = assemble(circuit,
self.backend,
shots=1)
self.param_names = [
"Quantum Fourier Transform", "Fusion Activated", "Use cu1 gate"
]
self.params = (num_qubits, [True, False], [True, False])
@staticmethod
def qft_circuit(num_qubit, use_cu1):
qreg = QuantumRegister(num_qubit, "q")
creg = ClassicalRegister(num_qubit, "c")
circuit = QuantumCircuit(qreg, creg)
for i in range(num_qubit):
circuit.h(qreg[i])
for i in range(num_qubit):
for j in range(i):
l = math.pi / float(2**(i - j))
if use_cu1:
circuit.cu1(l, qreg[i], qreg[j])
else:
circuit.u1(l / 2, qreg[i])
circuit.cx(qreg[i], qreg[j])
circuit.u1(-l / 2, qreg[j])
circuit.cx(qreg[i], qreg[j])
circuit.u1(l / 2, qreg[j])
circuit.h(qreg[i])
circuit.barrier()
for i in range(num_qubit):
circuit.measure(qreg[i], creg[i])
return circuit
def time_quantum_fourier_transform(self, num_qubit, fusion_enable,
use_cu1):
""" Benchmark QFT """
result = self.backend.run(self.circuit[(num_qubit, use_cu1)],
backend_options={
'fusion_enable': fusion_enable
}).result()
if result.status != 'COMPLETED':
raise QiskitError("Simulation failed. Status: " + result.status)
def SimW(cir):
simulator_qasm = BasicAer.get_backend('qasm_simulator')
noise_simulator = QasmSimulator.from_backend(device_backend)
if intro_noise == 0:
simulator = simulator_qasm
else:
simulator = noise_simulator
result = execute(cir, simulator, shots=num_shot).result()
counts = result.get_counts(cir)
#plot_histogram(counts, title='Bell-State counts')
return counts
def __init__(self):
self.timeout = 60 * 20
self.qft_circuits = []
self.backend = QasmSimulator()
for num_qubits in (5, 10, 15):
circ = quantum_fourier_transform_circuit(num_qubits)
circ = transpile(circ)
qobj = assemble(circ, self.backend, shots=1)
self.qft_circuits.append(qobj)
self.param_names = ["Quantum Fourier Transform", "Noise Model"]
# This will run every benchmark for one of the combinations we have here:
# bench(qft_circuits, None) => bench(qft_circuits, mixed()) =>
# bench(qft_circuits, reset) => bench(qft_circuits, kraus())
self.params = (self.qft_circuits, [
no_noise(),
mixed_unitary_noise_model(),
reset_noise_model(),
kraus_noise_model()
])
class TestQasmSimulatorDensityMatrixThrustGPU(common.QiskitAerTestCase,
DensityMatrixTests):
"""QasmSimulator density_matrix_gpu method tests."""
BACKEND_OPTS = {
"seed_simulator": 314159,
"method": "density_matrix_gpu",
"max_parallel_threads": 1
}
try:
SIMULATOR = QasmSimulator(**BACKEND_OPTS)
except AerError:
SIMULATOR = None
class QuantumFourierTransformTimeSuite:
"""
Benchmarking times for Quantum Fourier Transform with various noise configurations
- ideal (no noise)
- mixed state
- reset
- kraus
For each noise model, we want to test various configurations of number of
qubits
The methods defined in this class will be executed by ASV framework as many
times as the combination of all parameters exist in `self.params`, for
exmaple: self.params = ([1,2,3],[4,5,6]), will run all methdos 9 times:
time_method(1,4)
time_method(1,5)
time_method(1,6)
time_method(2,4)
time_method(2,5)
time_method(2,6)
time_method(3,4)
time_method(3,5)
time_method(3,6)
"""
def __init__(self):
self.timeout = 60 * 20
self.qft_circuits = []
self.backend = QasmSimulator()
for num_qubits in (5, 10, 15):
circ = quantum_fourier_transform_circuit(num_qubits)
circ = transpile(circ)
qobj = assemble(circ, self.backend, shots=1)
self.qft_circuits.append(qobj)
self.param_names = ["Quantum Fourier Transform", "Noise Model"]
# This will run every benchmark for one of the combinations we have here:
# bench(qft_circuits, None) => bench(qft_circuits, mixed()) =>
# bench(qft_circuits, reset) => bench(qft_circuits, kraus())
self.params = (self.qft_circuits, [
no_noise(),
mixed_unitary_noise_model(),
reset_noise_model(),
kraus_noise_model()
])
def setup(self, qobj, noise_model_wrapper):
pass
def time_quantum_fourier_transform(self, qobj, noise_model_wrapper):
result = self.backend.run(qobj,
noise_model=noise_model_wrapper()).result()
if result.status != 'COMPLETED':
raise QiskitError("Simulation failed. Status: " + result.status)
class RandomFusionSuite:
def __init__(self):
self.timeout = 60 * 20
self.backend = QasmSimulator()
self.param_names = ["Number of Qubits", "Fusion Activated"]
self.params = ([5, 10, 15, 20, 25], [True, False])
@staticmethod
def build_model_circuit_kak(width, depth, seed=None):
"""Create quantum volume model circuit on quantum register qreg of given
depth (default depth is equal to width) and random seed.
The model circuits consist of layers of Haar random
elements of U(4) applied between corresponding pairs
of qubits in a random bipartition.
"""
qreg = QuantumRegister(width)
depth = depth or width
np.random.seed(seed)
circuit = QuantumCircuit(qreg, name="Qvolume: %s by %s, seed: %s" % (width, depth, seed))
for _ in range(depth):
# Generate uniformly random permutation Pj of [0...n-1]
perm = np.random.permutation(width)
# For each pair p in Pj, generate Haar random U(4)
# Decompose each U(4) into CNOT + SU(2)
for k in range(width // 2):
U = random_unitary(4, seed).data
for gate in two_qubit_cnot_decompose(U):
qs = [qreg[int(perm[2 * k + i.index])] for i in gate[1]]
pars = gate[0].params
name = gate[0].name
if name == "cx":
circuit.cx(qs[0], qs[1])
elif name == "u1":
circuit.u1(pars[0], qs[0])
elif name == "u2":
circuit.u2(*pars[:2], qs[0])
elif name == "u3":
circuit.u3(*pars[:3], qs[0])
elif name == "id":
pass # do nothing
else:
raise Exception("Unexpected gate name: %s" % name)
return circuit
def time_random_transform(self, num_qubits, fusion_enable):
circ = self.build_model_circuit_kak(num_qubits, num_qubits, 1)
qobj = assemble(circ)
result = self.backend.run(qobj, fusion_enable=fusion_enable).result()
if result.status != 'COMPLETED':
raise QiskitError("Simulation failed. Status: " + result.status)
def calculateEnergy(self, transpiledCircuit):
if self.useNoiseModel == True:
p_reset = 0.003
p_meas = 0.01
p_gate1 = 0.05
# QuantumError objects
error_reset = pauli_error([('X', p_reset), ('I', 1 - p_reset)])
error_meas = pauli_error([('X', p_meas), ('I', 1 - p_meas)])
error_gate1 = pauli_error([('X', p_gate1), ('I', 1 - p_gate1)])
error_gate2 = error_gate1.tensor(error_gate1)
noise_bit_flip = NoiseModel()
noise_bit_flip.add_all_qubit_quantum_error(error_reset, "reset")
noise_bit_flip.add_all_qubit_quantum_error(error_meas, "measure")
noise_bit_flip.add_all_qubit_quantum_error(error_gate1, ["u1", "u2", "u3"])
noise_bit_flip.add_all_qubit_quantum_error(error_gate2, ["cx"])
simulator = QasmSimulator()
job = execute(transpiledCircuit, backend=simulator, basis_gates=noise_bit_flip.basis_gates, noise_model=noise_bit_flip)
results = job.result()
counts = results.get_counts()
_paulis, sgift = get_pauliList(self.ising, self.qubits)
_basis = [(pauli[1], [i]) for i, pauli in enumerate(_paulis)]
num_shots = sum(list(results.get_counts().values()))
results = parallel_map(WeightedPauliOperator._routine_compute_mean_and_var,
[([_paulis[idx] for idx in indices],
results.get_counts())
for basis, indices in _basis],
num_processes=aqua_globals.num_processes)
return results[0][0]
else:
_paulis, sgift = get_pauliList(self.ising, self.qubits)
_basis = [(pauli[1], [i]) for i, pauli in enumerate(_paulis)]
job = execute(transpiledCircuit, backend=self.backend)
results = job.result()
counts = results.get_counts()
num_shots = sum(list(results.get_counts().values()))
results = parallel_map(WeightedPauliOperator._routine_compute_mean_and_var,
[([_paulis[idx] for idx in indices],
results.get_counts())
for basis, indices in _basis],
num_processes=aqua_globals.num_processes)
return results[0][0]
class TestQasmSimulatorStatevectorMPI(common.QiskitAerTestCase,
StatevectorMPITests):
"""QasmSimulator statevector method MPI tests."""
BACKEND_OPTS = {
"seed_simulator": 271828,
"method": "statevector",
"blocking_enable": True,
"blocking_qubits": 6,
"max_parallel_threads": 1
}
SIMULATOR = QasmSimulator(**BACKEND_OPTS)
def circuit2():
print("\nCircuit 2")
# Use Aer's qasm_simulator
simulator = QasmSimulator()
# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(3, 3, name="Circuit2")
# Add a H gate on qubit 0
circuit.h(0)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 1
circuit.cx(0, 1)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 1
circuit.cx(0, 2)
# Map the quantum measurement to the classical bits
circuit.measure([0,1,2], [0,1,2])
#
# compile the circuit down to low-level QASM instructions
# supported by the backend (not needed for simple circuits)
compiled_circuit = transpile(circuit, simulator)
# Execute the circuit on the qasm simulator
job = simulator.run(compiled_circuit, shots=100)
# Grab results from the job
result = job.result()
# Draw the circuit
#circuit.draw()
print(circuit)
circuit.draw(output='mpl', filename='E:\_Ricks\Python\Qiskit1\circuit2.png')
# Returns counts
counts = result.get_counts(circuit)
print("\nTotal counts are:",counts)
class SimpleU3TimeSuite:
"""
Benchmark simple circuits with just one U3 gate
The methods defined in this class will be executed by ASV framework as many
times as the combination of all parameters exist in `self.params`, for
exmaple: self.params = ([1,2,3],[4,5,6]), will run all methdos 9 times:
time_method(1,4)
time_method(1,5)
time_method(1,6)
time_method(2,4)
time_method(2,5)
time_method(2,6)
time_method(3,4)
time_method(3,5)
time_method(3,6)
For each noise model, we want to test various configurations of number of
qubits
"""
def __init__(self):
self.timeout = 60 * 20
self.backend = QasmSimulator()
self.circuits = []
for i in 5, 10, 15:
circuit = simple_u3_circuit(i)
self.circuits.append(
Terra.compile(circuit, self.backend, shots=1)
)
self.param_names = [
"Simple u3 circuits (5/16/20/30 qubits)",
"Noise model"
]
self.params = (
self.circuits,
[
None,
mixed_unitary_noise_model(),
reset_noise_model(),
kraus_noise_model()
]
)
def time_simple_u3(self, qobj, noise_model):
result = self.backend.run(
qobj,
noise_model=noise_model
).result()
if result.status != 'COMPLETED':
raise QiskitError("Simulation failed. Status: " + result.status)
def __init__(self):
self.timeout = 60 * 20
self.qv_circuits = []
self.backend = QasmSimulator()
for num_qubits in (5, 10, 15):
for depth in (10, ):
# We want always the same seed, as we want always the same circuits
# for the same value pairs of qubits,depth
circ = quantum_volume_circuit(num_qubits, depth, seed=1)
circ = transpile(circ, basis_gates=['u3', 'cx'])
qobj = assemble(circ, self.backend, shots=1)
self.qv_circuits.append(qobj)
self.param_names = ["Quantum Volume", "Noise Model"]
# This will run every benchmark for one of the combinations we have here:
# bench(qv_circuits, None) => bench(qv_circuits, mixed()) =>
# bench(qv_circuits, reset) => bench(qv_circuits, kraus())
self.params = (self.qv_circuits, [
no_noise(),
mixed_unitary_noise_model(),
reset_noise_model(),
kraus_noise_model()
])
def __init__(self):
self.timeout = 60 * 20
self.backend = QasmSimulator()
self.circuits = []
self.param_names = [
"Simple cnot circuits (5/16/20/30 qubits)",
"Noise model"
]
for i in 5, 10, 15:
circuit = simple_cnot_circuit(i)
self.circuits.append(
Terra.compile(circuit, self.backend, shots=1)
)
self.params = (
self.circuits,
[
None,
mixed_unitary_noise_model(),
reset_noise_model(),
kraus_noise_model()
]
)
class TestQasmSimulatorStatevectorThrustGPU(common.QiskitAerTestCase,
StatevectorTests):
"""QasmSimulator statevector_gpu method tests."""
BACKEND_OPTS = {
"seed_simulator": 271828,
"method": "statevector_gpu",
"max_parallel_threads": 1
}
try:
SIMULATOR = QasmSimulator(**BACKEND_OPTS)
except AerError:
SIMULATOR = None
def test_quantum_instance_with_backend_shots(self):
"""Test sampling a circuit where the backend has shots attached."""
try:
from qiskit.providers.aer import QasmSimulator
except Exception as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
backend = QasmSimulator(shots=10)
sampler = CircuitSampler(backend)
res = sampler.convert(~Plus @ Plus).eval()
self.assertAlmostEqual(res, 1 + 0j, places=2)
