def test_cswap_gate_nondeterministic_minimal_basis_gates(self):
"""Test cswap-gate gate circuits compiling to u3,cx"""
circuits = ref_non_clifford.cswap_gate_circuits_nondeterministic(
final_measure=False)
targets = ref_non_clifford.cswap_gate_statevector_nondeterministic()
job = execute(circuits, StatevectorSimulator(), shots=1, basis_gates=['u3', 'cx'])
result = job.result()
self.assertTrue(getattr(result, 'success', False))
self.compare_statevector(result, circuits, targets)
def test_initialize_2(self):
"""Test StatevectorSimulator initialize"""
circuits = ref_initialize.initialize_circuits_2(final_measure=False)
targets = ref_initialize.initialize_statevector_2()
qobj = assemble(circuits, shots=1)
sim_job = StatevectorSimulator().run(qobj)
result = sim_job.result()
self.assertTrue(getattr(result, 'success', False))
self.compare_statevector(result, circuits, targets)
def test_cz_gate_deterministic_waltz_basis_gates(self):
"""Test cz-gate gate circuits compiling to u1,u2,u3,cx"""
circuits = ref_2q_clifford.cz_gate_circuits_deterministic(final_measure=False)
targets = ref_2q_clifford.cz_gate_statevector_deterministic()
job = execute(circuits, StatevectorSimulator(), shots=1,
basis_gates=['u1', 'u2', 'u3', 'cx'])
result = job.result()
self.assertTrue(getattr(result, 'success', False))
self.compare_statevector(result, circuits, targets)
def test_conditional_2bit(self):
"""Test conditional operations on 2-bit conditional register."""
circuits = ref_conditionals.conditional_circuits_2bit(
final_measure=False)
targets = ref_conditionals.conditional_statevector_2bit()
job = execute(circuits, StatevectorSimulator(), shots=1)
result = job.result()
self.is_completed(result)
self.compare_statevector(result, circuits, targets)
def test_conditional_unitary_2bit(self):
"""Test conditional unitary on 2-bit conditional register."""
circuits = ref_conditionals.conditional_circuits_2bit(final_measure=False,
conditional_type='unitary')
targets = ref_conditionals.conditional_statevector_2bit()
job = execute(circuits, StatevectorSimulator(), shots=1)
result = job.result()
self.assertTrue(getattr(result, 'success', False))
self.compare_statevector(result, circuits, targets)
def test_measure(self):
"""Test StatevectorSimulator measure with deterministic counts"""
circuits = ref_measure.measure_circuits_deterministic(
allow_sampling=True)
targets = ref_measure.measure_statevector_deterministic()
job = execute(circuits, StatevectorSimulator(), shots=1)
result = job.result()
self.is_completed(result)
self.compare_statevector(result, circuits, targets)
def test_ccx_gate_nondeterministic_default_basis_gates(self):
"""Test ccx-gate circuits compiling to backend default basis_gates."""
circuits = ref_non_clifford.ccx_gate_circuits_nondeterministic(
final_measure=False)
targets = ref_non_clifford.ccx_gate_statevector_nondeterministic()
job = execute(circuits, StatevectorSimulator(), shots=1)
result = job.result()
self.is_completed(result)
self.compare_statevector(result, circuits, targets)
def test_initialize_1(self):
"""Test StatevectorSimulator initialize"""
circuits = ref_initialize.initialize_circuits_1(final_measure=False)
targets = ref_initialize.initialize_statevector_1()
qobj = assemble(circuits, shots=1)
sim_job = StatevectorSimulator().run(qobj)
result = sim_job.result()
self.is_completed(result)
self.compare_statevector(result, circuits, targets)
def test_conditional_unitary_1bit(self):
"""Test conditional unitaries on 1-bit conditional register."""
circuits = ref_conditionals.conditional_circuits_1bit(
final_measure=False, conditional_type='unitary')
targets = ref_conditionals.conditional_statevector_1bit()
job = execute(circuits, StatevectorSimulator(), shots=1)
result = job.result()
self.is_completed(result)
self.compare_statevector(result, circuits, targets)
def test_measure_multi_qubit(self):
"""Test StatevectorSimulator multi-qubit measure with deterministic counts"""
qobj = ref_measure.measure_circuits_qobj_deterministic(
allow_sampling=True)
circuits = [experiment.header.name for experiment in qobj.experiments]
targets = ref_measure.measure_statevector_qobj_deterministic()
job = StatevectorSimulator().run(qobj)
result = job.result()
self.is_completed(result)
self.compare_statevector(result, circuits, targets)
def test_reset_deterministic(self):
"""Test StatevectorSimulator reset with for circuits with deterministic counts"""
# For statevector output we can combine deterministic and non-deterministic
# count output circuits
circuits = ref_reset.reset_circuits_deterministic(final_measure=False)
targets = ref_reset.reset_statevector_deterministic()
job = execute(circuits, StatevectorSimulator(), shots=1)
result = job.result()
self.is_completed(result)
self.compare_statevector(result, circuits, targets)
def test_reset_nondeterministic(self):
"""Test StatevectorSimulator reset with for circuits with non-deterministic counts"""
# For statevector output we can combine deterministic and non-deterministic
# count output circuits
circuits = ref_reset.reset_circuits_nondeterministic(final_measure=False)
targets = ref_reset.reset_statevector_nondeterministic()
job = execute(circuits, StatevectorSimulator(), shots=1)
result = job.result()
self.assertTrue(getattr(result, 'success', False))
self.compare_statevector(result, circuits, targets)
def test_y_gate_deterministic_minimal_basis_gates(self):
"""Test y-gate gate circuits compiling to U,CX
DISABLED until transpiler bug is fixed.
"""
circuits = ref_1q_clifford.y_gate_circuits_deterministic(final_measure=False)
targets = ref_1q_clifford.y_gate_statevector_deterministic()
job = execute(circuits, StatevectorSimulator(), shots=1, basis_gates=['u3', 'cx'])
result = job.result()
self.is_completed(result)
self.compare_statevector(result, circuits, targets)
def set_sv(sim_opts):
sim_method = [opt for opt in sim_opts if opt.startswith('method')]
if len(sim_method) == 0:
backend = StatevectorSimulator(max_memory_mb = 2048,
statevector_parallel_threshold=8)
sim_method = 'statevector'
else:
sim_method = sim_method[0].split('=')[1].strip('\n')
if sim_method not in sv_methods:
print('SimulationError: simulation method not available. Available options: "statevector"')
sys.exit()
else:
backend = StatevectorSimulator(max_memory_mb = 2048,
statevector_parallel_threshold=8)
return backend, sim_method
class TestStatevectorSimulatorThrustCPU(common.QiskitAerTestCase,
StatevectorGateTests,
StatevectorSimulatorTests,
StatevectorFusionTests):
"""StatevectorSimulator automatic method tests."""
BACKEND_OPTS = {"seed_simulator": 10598, "method": "statevector_thrust"}
try:
SIMULATOR = StatevectorSimulator(**BACKEND_OPTS)
except AerError:
SIMULATOR = None
def DISABLED_test_unitary_gate_complex(self):
"""Test unitary qobj instruction with complex matrices."""
qobj = ref_unitary_gate.unitary_gate_circuits_complex_deterministic(
final_measure=False)
circuits = [experiment.header.name for experiment in qobj.experiments]
targets = ref_unitary_gate.unitary_gate_statevector_complex_deterministic(
)
job = StatevectorSimulator().run(qobj)
result = job.result()
self.is_completed(result)
self.compare_statevector(result, circuits, targets)
def execute_circuit(G, gamma, beta, p=1): #Returns same as earlier, the counts
n = len(G.nodes())
QAOA = circuit_ansatz(G, gamma, beta, p=p)
result = execute(QAOA, backend=StatevectorSimulator()).result()
statevector = result.get_statevector(QAOA)
probabilities = ([abs(i)**2 for i in statevector])
state_dictionary = {
bin(i)[2:].zfill(n): probabilities[i]
for i in range(len(probabilities))
}
return state_dictionary
def test_swap_gate_nondeterministic_waltz_basis_gates(self):
"""Test swap-gate gate circuits compiling to u1,u2,u3,cx"""
circuits = ref_2q_clifford.swap_gate_circuits_nondeterministic(
final_measure=False)
targets = ref_2q_clifford.swap_gate_statevector_nondeterministic()
job = execute(circuits,
StatevectorSimulator(),
shots=1,
basis_gates='u1,u2,u3,cx')
result = job.result()
self.is_completed(result)
self.compare_statevector(result, circuits, targets)
def test_ccx_gate_nondeterministic_minimal_basis_gates(self):
"""Test ccx-gate gate circuits compiling to u3,cx"""
circuits = ref_non_clifford.ccx_gate_circuits_nondeterministic(
final_measure=False)
targets = ref_non_clifford.ccx_gate_statevector_nondeterministic()
job = execute(circuits,
StatevectorSimulator(),
shots=1,
basis_gates=['u3', 'cx'])
result = job.result()
self.is_completed(result)
self.compare_statevector(result, circuits, targets)
def test_tdg_gate_deterministic_waltz_basis_gates(self):
"""Test tdg-gate gate circuits compiling to u1,u2,u3,cx"""
circuits = ref_non_clifford.tdg_gate_circuits_deterministic(
final_measure=False)
targets = ref_non_clifford.tdg_gate_statevector_deterministic()
job = execute(circuits,
StatevectorSimulator(),
shots=1,
basis_gates=['u1', 'u2', 'u3', 'cx'])
result = job.result()
self.is_completed(result)
self.compare_statevector(result, circuits, targets)
def test_tdg_gate_deterministic_minimal_basis_gates(self):
"""Test tdg-gate gate circuits compiling to U,CX"""
circuits = ref_non_clifford.tdg_gate_circuits_deterministic(
final_measure=False)
targets = ref_non_clifford.tdg_gate_statevector_deterministic()
job = execute(circuits,
StatevectorSimulator(),
shots=1,
basis_gates='U,CX')
result = job.result()
self.is_completed(result)
self.compare_statevector(result, circuits, targets)
def setUp(self):
super().setUp()
# specify "run configuration"
quantum_instance = QuantumInstance(StatevectorSimulator())
# define QNN
num_qubits = 2
feature_map = ZZFeatureMap(num_qubits)
ansatz = RealAmplitudes(num_qubits, reps=1)
self.qnn = TwoLayerQNN(num_qubits, feature_map=feature_map,
ansatz=ansatz, quantum_instance=quantum_instance)
self.qnn_no_qi = TwoLayerQNN(num_qubits, feature_map=feature_map,
ansatz=ansatz)
def test_parameterized_qobj_statevector(self):
"""Test parameterized qobj with Expectation Value snapshot and qasm simulator."""
statevec_targets = snapshot_expval_final_statevecs() * 3
backend = StatevectorSimulator()
qobj = self.parameterized_qobj(backend=backend,
measure=False,
snapshot=False)
self.assertIn('parameterizations', qobj.to_dict()['config'])
job = backend.run(qobj, self.BACKEND_OPTS)
result = job.result()
success = getattr(result, 'success', False)
num_circs = len(result.to_dict()['results'])
self.assertTrue(success)
for j in range(num_circs):
statevector = result.get_statevector(j)
np.testing.assert_array_almost_equal(statevector,
statevec_targets[j].data,
decimal=7)
'0x0': 5 * shots / 8,
'0x1': shots / 8,
'0x2': shots / 8,
'0x3': shots / 8
}]
simulator = QasmSimulator()
qobj = assemble(transpile(circuits, simulator), simulator, shots=shots)
result = simulator.run(qobj).result()
assert result.status == 'COMPLETED'
compare_counts(result, circuits, targets, delta=0.05 * shots)
assert result.success is True
# Run statevector simulator
circuits = cx_gate_circuits_deterministic(final_measure=False)
targets = cx_gate_statevector_deterministic()
job = execute(circuits, StatevectorSimulator(), shots=1)
result = job.result()
assert result.status == 'COMPLETED'
assert result.success is True
compare_statevector(result, circuits, targets)
# Run unitary simulator
circuits = cx_gate_circuits_deterministic(final_measure=False)
targets = cx_gate_unitary_deterministic()
job = execute(circuits,
UnitarySimulator(),
shots=1,
basis_gates=['u1', 'u2', 'u3', 'cx'])
result = job.result()
assert result.status == 'COMPLETED'
assert result.success is True
def show_matrix(G, gamma, beta, p=1, state=0):
n = len(G.nodes())
E = G.edges()
QAOA = QuantumCircuit(n, n)
if state == 1:
QAOA.x(0)
elif state == 2:
QAOA.x(1)
elif state == 3:
QAOA.x(0)
QAOA.x(1)
#QAOA.h(range(n))
#QAOA.barrier()
#plt.savefig(f'Initial State bad')
np.set_printoptions(precision=3, suppress=True)
for i in range(p):
for edge in E:
k = edge[0]
l = edge[1]
QAOA.cu1(-2 * gamma[i], k,
l) #Controlled-Z gate with a -2*gamma phase
QAOA.u1(gamma[i], k) #Rotation of gamma around the z axis
QAOA.u1(gamma[i], l)
b = []
c = []
c_p = []
b_p = []
statevector = execute(
QAOA,
backend=StatevectorSimulator()).result().get_statevector(QAOA)
c = np.array(statevector[:])
#print(f'The amplitudes after applying U_C are :\n {statevector}')
probabilities = np.array(([abs(i)**2 for i in statevector]))
c_p = np.array(probabilities[:])
#print(f'The probabilities after applying U_C are :\n {probabilities}')
state_dict = {
bin(i)[2:].zfill(n): probabilities[i]
for i in range(len(probabilities))
}
QAOA.barrier()
QAOA.rx(2 * beta[i], range(n)) #X rotation
statevector = execute(
QAOA,
backend=StatevectorSimulator()).result().get_statevector(QAOA)
b = np.array(statevector[:])
#print(f'The amplitudes after applying U_b are :\n {statevector}')
probabilities = np.array(([abs(i)**2 for i in statevector]))
b_p = np.array(probabilities[:])
#print(f'The probabilities after applying U_B are :\n {probabilities}')
state_dict = {
bin(i)[2:].zfill(n): probabilities[i]
for i in range(len(probabilities))
}
QAOA.barrier()
return c, b, c_p, b_p
import pylab as pl
# Qiskit
from qiskit.providers.aer import StatevectorSimulator
from qiskit import QuantumCircuit, execute
# Optimizers
from scipy.optimize import minimize, differential_evolution
# Choose your fighter
G = graphs.two_nodes_graph()
n = len(G.nodes())
E = G.edges()
# Choose the arena
backend = StatevectorSimulator()
# Choose number of rounds
p = 1
#colors = ['g' for node in G.nodes()]
#nx.draw_networkx(G, node_color=colors)
def give_cost(G, gamma, beta, p=1):
n = len(G.nodes())
E = G.edges()
QAOA = QuantumCircuit(n, n)
QAOA.h(range(n))
QAOA.barrier()
class StatevectorFusionTests:
"""StatevectorSimulator fusion tests."""
SIMULATOR = StatevectorSimulator()
def fusion_options(self, enabled=None, threshold=None, verbose=None):
"""Return default backend_options dict."""
backend_options = self.BACKEND_OPTS.copy()
if enabled is not None:
backend_options['fusion_enable'] = enabled
if verbose is not None:
backend_options['fusion_verbose'] = verbose
if threshold is not None:
backend_options['fusion_threshold'] = threshold
return backend_options
def fusion_metadata(self, result):
"""Return fusion metadata dict"""
metadata = result.results[0].metadata
return metadata.get('fusion', {})
def test_fusion_theshold(self):
"""Test fusion threhsold settings work."""
seed = 12345
threshold = 4
backend_options = self.fusion_options(enabled=True,
threshold=threshold)
with self.subTest(msg='below fusion threshold'):
circuit = QuantumVolume(threshold - 1, seed=seed)
circuit = transpile(circuit, self.SIMULATOR)
qobj = assemble([circuit], shots=1)
result = self.SIMULATOR.run(
qobj, backend_options=backend_options).result()
meta = self.fusion_metadata(result)
self.assertSuccess(result)
self.assertFalse(meta.get('applied'))
with self.subTest(msg='at fusion threshold'):
circuit = QuantumVolume(threshold, seed=seed)
circuit = transpile(circuit, self.SIMULATOR)
qobj = assemble([circuit], shots=1)
result = self.SIMULATOR.run(
qobj, backend_options=backend_options).result()
meta = self.fusion_metadata(result)
self.assertSuccess(result)
self.assertTrue(meta.get('applied'))
with self.subTest(msg='above fusion threshold'):
circuit = QuantumVolume(threshold + 1, seed=seed)
circuit = transpile(circuit, self.SIMULATOR)
qobj = assemble([circuit], shots=1)
result = self.SIMULATOR.run(
qobj, backend_options=backend_options).result()
meta = self.fusion_metadata(result)
self.assertSuccess(result)
self.assertTrue(meta.get('applied'))
def test_fusion_disable(self):
"""Test Fusion enable/disable option"""
seed = 2233
circuit = QuantumVolume(4, seed=seed)
circuit = transpile(circuit, self.SIMULATOR)
qobj = assemble([circuit], shots=1)
with self.subTest(msg='test fusion enable'):
backend_options = self.fusion_options(enabled=True, threshold=1)
result = self.SIMULATOR.run(
qobj, backend_options=backend_options).result()
meta = self.fusion_metadata(result)
self.assertSuccess(result)
self.assertTrue(meta.get('applied'))
with self.subTest(msg='test fusion disable'):
backend_options = self.fusion_options(enabled=False, threshold=1)
result = self.SIMULATOR.run(
qobj, backend_options=backend_options).result()
meta = self.fusion_metadata(result)
self.assertSuccess(result)
self.assertFalse(meta.get('applied'))
def test_fusion_output(self):
"""Test Fusion returns same final unitary"""
seed = 54321
circuit = QuantumVolume(4, seed=seed)
circuit = transpile(circuit, self.SIMULATOR)
qobj = assemble([circuit], shots=1)
options_disabled = self.fusion_options(enabled=False, threshold=1)
result_disabled = self.SIMULATOR.run(
qobj, backend_options=options_disabled).result()
self.assertSuccess(result_disabled)
options_enabled = self.fusion_options(enabled=True, threshold=1)
result_enabled = self.SIMULATOR.run(
qobj, backend_options=options_enabled).result()
self.assertSuccess(result_enabled)
sv_no_fusion = Statevector(result_disabled.get_statevector(0))
sv_fusion = Statevector(result_enabled.get_statevector(0))
self.assertEqual(sv_no_fusion, sv_fusion)
def setUp(self):
super().setUp()
# specify quantum instances
self.sv_quantum_instance = QuantumInstance(StatevectorSimulator())
self.qasm_quantum_instance = QuantumInstance(AerSimulator(), shots=100)
def show_amplitudes(G, gamma, beta, p=1):
n = len(G.nodes())
E = G.edges()
QAOA = QuantumCircuit(n, n)
QAOA.h(range(n))
QAOA.barrier()
fig = plt.figure()
bar_graph = plt.bar(range(2**n), [1 / (2**n) for i in range(2**n)],
align='center')
x_ticks = [bin(i)[2:].zfill(n) for i in range(2**n)]
plt.xticks(ticks=range(2**n), labels=x_ticks, rotation=60)
plt.ylim(0, 0.75)
plt.title(f'Initial State')
fig.canvas.draw()
plt.pause(1)
#plt.savefig(f'Initial State bad')
for i in range(p):
for edge in E:
k = edge[0]
l = edge[1]
QAOA.cu1(-2 * gamma[i], k,
l) #Controlled-Z gate with a -2*gamma phase
QAOA.u1(gamma[i], k) #Rotation of gamma around the z axis
QAOA.u1(gamma[i], l)
statevector = execute(
QAOA,
backend=StatevectorSimulator()).result().get_statevector(QAOA)
probabilities = ([abs(i)**2 for i in statevector])
state_dict = {
bin(i)[2:].zfill(n): probabilities[i]
for i in range(len(probabilities))
}
for rectangle, probs in zip(bar_graph, probabilities):
rectangle.set_height(probs)
plt.title(
f'Cost: {get_expectval(state_dict, G)}\n Iteration {i + 1}, after applying $U_C$\n $\gamma$ = {gamma[i]}'
)
fig.canvas.draw()
#plt.savefig(f'{i} gamma bad')
plt.pause(0.5)
QAOA.barrier()
QAOA.rx(2 * beta[i], range(n)) #X rotation
statevector = execute(
QAOA,
backend=StatevectorSimulator()).result().get_statevector(QAOA)
probabilities = ([abs(i)**2 for i in statevector])
state_dict = {
bin(i)[2:].zfill(n): probabilities[i]
for i in range(len(probabilities))
}
for rectangle, probs in zip(bar_graph, probabilities):
rectangle.set_height(probs)
plt.title(
f'Cost: {get_expectval(state_dict, G)}\n Iteration {i + 1}, after applying $U_B$\n $\\beta$ = {beta[i]}'
)
fig.canvas.draw()
#plt.savefig(f'{i} beta bad')
plt.pause(0.5)
QAOA.barrier()
plt.show()
coupling_map = backend.configuration().coupling_map
noise_model = NoiseModel.from_backend(backend)
sim_backend = QasmSimulator(method='statevector',
max_parallel_shots=0,
max_parallel_threads=0,
noise_model=noise_model)
pass_manager = noise_pass_manager(coupling_map=coupling_map,
layout_method='noise_adaptive',
seed_transpiler=1000,
routing_method='noise_adaptive',
backend_properties=properties,
alpha=0.5)
ideal_result = execute(qc, backend=StatevectorSimulator()).result()
ideal_counts = Statevector(
ideal_result.get_statevector(qc)).sample_counts(8192)
ideal_probs = Statevector(ideal_result.get_statevector()).probabilities_dict()
qiskit_na_t_result = execute(qc,
backend=sim_backend,
shots=8192,
pass_manager=pass_manager,
noise_model=noise_model).result()
sampled_counts = qiskit_na_t_result.get_counts(qc)
hellinger_fidelity = hellinger_fidelity(ideal_counts, sampled_counts)
hog = hog(sampled_counts, ideal_probs)
l1_norm = l1_norm(sampled_counts, ideal_probs)
