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_tdg_gate_deterministic_default_basis_gates(self):
"""Test tdg-gate circuits compiling to backend default basis_gates."""
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)
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.is_completed(result)
self.compare_statevector(result, circuits, targets)
def test_conditional_gate_1bit(self):
"""Test conditional gates on 1-bit conditional register."""
circuits = ref_conditionals.conditional_circuits_1bit(
final_measure=False)
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_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 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_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 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
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)
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
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 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_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_t_gate_deterministic_minimal_basis_gates(self):
"""Test t-gate gate circuits compiling to U,CX"""
circuits = ref_non_clifford.t_gate_circuits_deterministic(
final_measure=False)
targets = ref_non_clifford.t_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 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 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)
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 StatevectorSimulatorTests:
"""StatevectorSimulator tests."""
SIMULATOR = StatevectorSimulator()
BACKEND_OPTS = {}
# ---------------------------------------------------------------------
# Test initialize
# ---------------------------------------------------------------------
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 = self.SIMULATOR.run(qobj, **self.BACKEND_OPTS)
result = sim_job.result()
self.assertSuccess(result)
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 = self.SIMULATOR.run(qobj, **self.BACKEND_OPTS)
result = sim_job.result()
self.assertSuccess(result)
self.compare_statevector(result, circuits, targets)
# ---------------------------------------------------------------------
# Test reset
# ---------------------------------------------------------------------
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, self.SIMULATOR, shots=1, **self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(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, self.SIMULATOR, shots=1, **self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_statevector(result, circuits, targets)
# ---------------------------------------------------------------------
# Test measure
# ---------------------------------------------------------------------
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, self.SIMULATOR, shots=1, **self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_statevector(result, circuits, targets)
# ---------------------------------------------------------------------
# Test conditional
# ---------------------------------------------------------------------
def test_conditional_gate_1bit(self):
"""Test conditional gates on 1-bit conditional register."""
circuits = ref_conditionals.conditional_circuits_1bit(
final_measure=False)
targets = ref_conditionals.conditional_statevector_1bit()
job = execute(circuits, self.SIMULATOR, shots=1, **self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(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, self.SIMULATOR, shots=1, **self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_statevector(result, circuits, targets)
def test_conditional_gate_2bit(self):
"""Test conditional gates on 2-bit conditional register."""
circuits = ref_conditionals.conditional_circuits_2bit(
final_measure=False)
targets = ref_conditionals.conditional_statevector_2bit()
job = execute(circuits, self.SIMULATOR, shots=1, **self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(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, self.SIMULATOR, shots=1, **self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_statevector(result, circuits, targets)
def test_conditional_gate_64bit(self):
"""Test conditional gates on 64-bit conditional register."""
cases = ref_conditionals.conditional_cases_64bit()
circuits = ref_conditionals.conditional_circuits_nbit(
64, cases, final_measure=False, conditional_type='gate')
targets = ref_conditionals.conditional_statevector_nbit(cases)
job = execute(circuits, self.SIMULATOR, shots=1, **self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_statevector(result, circuits, targets)
def test_conditional_unitary_64bit(self):
"""Test conditional unitary on 64-bit conditional register."""
cases = ref_conditionals.conditional_cases_64bit()
circuits = ref_conditionals.conditional_circuits_nbit(
64, cases, final_measure=False, conditional_type='unitary')
targets = ref_conditionals.conditional_statevector_nbit(cases)
job = execute(circuits, self.SIMULATOR, shots=1, **self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_statevector(result, circuits, targets)
def test_conditional_gate_132bit(self):
"""Test conditional gates on 132-bit conditional register."""
cases = ref_conditionals.conditional_cases_132bit()
circuits = ref_conditionals.conditional_circuits_nbit(
132, cases, final_measure=False, conditional_type='gate')
targets = ref_conditionals.conditional_statevector_nbit(cases)
job = execute(circuits, self.SIMULATOR, shots=1, **self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_statevector(result, circuits, targets)
def test_conditional_unitary_132bit(self):
"""Test conditional unitary on 132-bit conditional register."""
cases = ref_conditionals.conditional_cases_132bit()
circuits = ref_conditionals.conditional_circuits_nbit(
132, cases, final_measure=False, conditional_type='unitary')
targets = ref_conditionals.conditional_statevector_nbit(cases)
job = execute(circuits, self.SIMULATOR, shots=1, **self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_statevector(result, circuits, targets)
# ---------------------------------------------------------------------
# Test unitary gate qobj instruction
# ---------------------------------------------------------------------
def test_unitary_gate(self):
"""Test simulation with unitary gate circuit instructions."""
circuits = ref_unitary_gate.unitary_gate_circuits_deterministic(
final_measure=False)
targets = ref_unitary_gate.unitary_gate_statevector_deterministic()
job = execute(circuits, self.SIMULATOR, shots=1, **self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_statevector(result, circuits, targets)
def test_diagonal_gate(self):
"""Test simulation with diagonal gate circuit instructions."""
circuits = ref_diagonal_gate.diagonal_gate_circuits_deterministic(
final_measure=False)
targets = ref_diagonal_gate.diagonal_gate_statevector_deterministic()
job = execute(circuits, self.SIMULATOR, shots=1, **self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_statevector(result, circuits, targets)
self.compare_statevector(result, circuits, targets)
# ---------------------------------------------------------------------
# Test global phase
# ---------------------------------------------------------------------
def test_qobj_global_phase(self):
"""Test qobj global phase."""
circuits = ref_1q_clifford.h_gate_circuits_nondeterministic(
final_measure=False)
targets = ref_1q_clifford.h_gate_statevector_nondeterministic()
qobj = assemble(transpile(circuits, self.SIMULATOR),
shots=1,
**self.BACKEND_OPTS)
# Set global phases
for i, _ in enumerate(circuits):
global_phase = (-1)**i * (pi / 4)
qobj.experiments[i].header.global_phase = global_phase
targets[i] = exp(1j * global_phase) * targets[i]
result = self.SIMULATOR.run(qobj).result()
self.assertSuccess(result)
self.compare_statevector(result, circuits, targets, ignore_phase=False)
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)
assert result.status == 'COMPLETED'
assert result.success is True
compare_counts(result, circuits, targets, delta=0.05 * shots)
# Run qasm simulator
simulator = QasmSimulator()
result = simulator.run(transpile(circuits, simulator),
shots=shots).result()
assert result.status == 'COMPLETED'
assert result.success is True
compare_counts(result, circuits, targets, delta=0.05 * shots)
# Run statevector simulator
circuits = cx_gate_circuits_deterministic(final_measure=False)
targets = cx_gate_statevector_deterministic()
backend = StatevectorSimulator()
result = backend.run(transpile(circuits, backend), shots=1).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()
backend = UnitarySimulator()
result = backend.run(transpile(circuits, backend), shots=1).result()
assert result.status == 'COMPLETED'
assert result.success is True
compare_unitary(result, circuits, targets)
# Run pulse simulator
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()
class StatevectorGateTests:
"""StatevectorSimulator circuit library standard gate tests."""
SIMULATOR = StatevectorSimulator()
BACKEND_OPTS = {}
SEED = 8181
RNG = default_rng(seed=SEED)
GATES = [
# Clifford Gates
(CXGate, 0),
(CYGate, 0),
(CZGate, 0),
(DCXGate, 0),
(HGate, 0),
(IGate, 0),
(SGate, 0),
(SXGate, 0),
(SXdgGate, 0),
(SdgGate, 0),
(SwapGate, 0),
(XGate, 0),
(YGate, 0),
(ZGate, 0),
(TGate, 0),
# Non-Clifford Gates
(TdgGate, 0),
(iSwapGate, 0),
(C3XGate, 0),
(C4XGate, 0),
(CCXGate, 0),
(CHGate, 0),
(CSXGate, 0),
(CSwapGate, 0),
# Parameterized Gates
(CPhaseGate, 1),
(CRXGate, 1),
(CRYGate, 1),
(CRZGate, 1),
(CU1Gate, 1),
(CU3Gate, 3),
(CUGate, 4),
(PhaseGate, 1),
(RC3XGate, 1),
(RCCXGate, 1),
(RGate, 2),
(RXGate, 1),
(RXXGate, 1),
(RYGate, 1),
(RYYGate, 1),
(RZGate, 1),
(RZXGate, 1),
(RZZGate, 1),
(U1Gate, 1),
(U2Gate, 2),
(U3Gate, 3),
(UGate, 3)
]
BASIS_GATES = [
None, ['id', 'u1', 'u2', 'u3', 'cx'], ['id', 'u', 'cx'],
['id', 'r', 'cz'], ['id', 'rz', 'rx', 'cz'], ['id', 'p', 'sx', 'cx']
]
@data(*[(gate_params[0], gate_params[1], basis_gates)
for gate_params, basis_gates in product(GATES, BASIS_GATES)])
@unpack
def test_gate(self, gate_cls, num_params, basis_gates):
"""Test standard gate simulation."""
circuits = self.gate_circuits(gate_cls,
num_params=num_params,
rng=self.RNG)
for circuit in circuits:
target = Statevector.from_instruction(circuit)
result = execute(circuit, self.SIMULATOR,
basis_gates=basis_gates).result()
self.assertSuccess(result)
value = Statevector(result.get_statevector(0))
self.assertTrue(target.equiv(value),
msg='{}, basis_gates = {}'.format(
gate_cls.__name__, basis_gates))
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
'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
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)
