def test_run_2qubit(self):
"""test for 2-qubit cases"""
qc0 = QuantumCircuit(2)
qc0.measure_all()
qc1 = QuantumCircuit(2)
qc1.x(0)
qc1.measure_all()
qc2 = QuantumCircuit(2)
qc2.x(1)
qc2.measure_all()
qc3 = QuantumCircuit(2)
qc3.x([0, 1])
qc3.measure_all()
sampler = Sampler()
result = sampler.run([qc0, qc1, qc2, qc3]).result()
self.assertIsInstance(result, SamplerResult)
self.assertEqual(len(result.quasi_dists), 4)
keys, values = zip(*sorted(result.quasi_dists[0].items()))
self.assertTupleEqual(keys, tuple(range(4)))
np.testing.assert_allclose(values, [1, 0, 0, 0])
keys, values = zip(*sorted(result.quasi_dists[1].items()))
self.assertTupleEqual(keys, tuple(range(4)))
np.testing.assert_allclose(values, [0, 1, 0, 0])
keys, values = zip(*sorted(result.quasi_dists[2].items()))
self.assertTupleEqual(keys, tuple(range(4)))
np.testing.assert_allclose(values, [0, 0, 1, 0])
keys, values = zip(*sorted(result.quasi_dists[3].items()))
self.assertTupleEqual(keys, tuple(range(4)))
np.testing.assert_allclose(values, [0, 0, 0, 1])
def test_run_with_shots_option(self):
"""test with shots option."""
params, target = self._generate_params_target([1])
sampler = Sampler()
result = sampler.run(circuits=[self._pqc],
parameter_values=params,
shots=1024,
seed=15).result()
self._compare_probs(result.quasi_dists, target)
def test_sampler_run(self):
"""Test Sampler.run()."""
bell = self._circuit[1]
sampler = Sampler()
job = sampler.run(circuits=[bell])
self.assertIsInstance(job, JobV1)
result = job.result()
self.assertIsInstance(result, SamplerResult)
# print([q.binary_probabilities() for q in result.quasi_dists])
self._compare_probs(result.quasi_dists, self._target[1])
def test_sample_run_multiple_circuits(self):
"""Test Sampler.run() with multiple circuits."""
# executes three Bell circuits
# Argument `parameters` is optional.
bell = self._circuit[1]
sampler = Sampler()
result = sampler.run([bell, bell, bell]).result()
# print([q.binary_probabilities() for q in result.quasi_dists])
self._compare_probs(result.quasi_dists[0], self._target[1])
self._compare_probs(result.quasi_dists[1], self._target[1])
self._compare_probs(result.quasi_dists[2], self._target[1])
def test_run_with_shots_option_none(self):
"""test with shots=None option. Seed is ignored then."""
sampler = Sampler()
result_42 = sampler.run([self._pqc],
parameter_values=[[0, 1, 1, 2, 3, 5]],
shots=None,
seed=42).result()
result_15 = sampler.run([self._pqc],
parameter_values=[[0, 1, 1, 2, 3, 5]],
shots=None,
seed=15).result()
self.assertDictAlmostEqual(result_42.quasi_dists,
result_15.quasi_dists)
def test_numpy_params(self):
"""Test for numpy array as parameter values"""
qc = RealAmplitudes(num_qubits=2, reps=2)
qc.measure_all()
k = 5
params_array = np.random.rand(k, qc.num_parameters)
params_list = params_array.tolist()
params_list_array = list(params_array)
with self.assertWarns(DeprecationWarning):
sampler = Sampler(circuits=qc)
target = sampler([0] * k, params_list)
with self.subTest("ndarrary"):
with self.assertWarns(DeprecationWarning):
result = sampler([0] * k, params_array)
self.assertEqual(len(result.metadata), k)
for i in range(k):
self.assertDictEqual(result.quasi_dists[i],
target.quasi_dists[i])
with self.subTest("list of ndarray"):
with self.assertWarns(DeprecationWarning):
result = sampler([0] * k, params_list_array)
self.assertEqual(len(result.metadata), k)
for i in range(k):
self.assertDictEqual(result.quasi_dists[i],
target.quasi_dists[i])
def test_sampler_pqc(self, indices):
"""test for sampler with a parametrized circuit"""
params, target = self._generate_params_target(indices)
with self.assertWarns(DeprecationWarning):
sampler = Sampler(circuits=self._pqc)
result = sampler([0] * len(params), params)
self._compare_probs(result.quasi_dists, target)
def test_evaluate_two_pqcs(self, indices):
"""test for sampler with two parametrized circuits"""
circs = [self._pqc, self._pqc]
params, target = self._generate_params_target(indices)
with Sampler(circuits=circs) as sampler:
result = sampler(parameter_values=params)
self._compare_probs(result.quasi_dists, target)
def test_evaluate_two_pqcs(self, indices):
"""test for sampler with two parametrized circuits"""
circs = [self._pqc, self._pqc]
params, target = self._generate_params_target(indices)
with self.assertWarns(DeprecationWarning):
sampler = Sampler(circuits=circs)
result = sampler(indices, parameter_values=params)
self._compare_probs(result.quasi_dists, target)
def test_sampler(self, indices):
"""test for sampler"""
circuits, target = self._generate_circuits_target(indices)
with self.assertWarns(DeprecationWarning):
sampler = Sampler(circuits=circuits)
result = sampler(list(range(len(indices))),
parameter_values=[[] for _ in indices])
self._compare_probs(result.quasi_dists, target)
def test_passing_objects(self):
"""Test passing objects for Sampler."""
params, target = self._generate_params_target([0])
with self.subTest("Valid test"):
with self.assertWarns(DeprecationWarning):
sampler = Sampler(circuits=self._pqc)
result = sampler(circuits=[self._pqc], parameter_values=params)
self._compare_probs(result.quasi_dists, target)
with self.subTest("Invalid circuit test"):
circuit = QuantumCircuit(2)
with self.assertWarns(DeprecationWarning):
sampler = Sampler(circuits=self._pqc)
with self.assertRaises(QiskitError), self.assertWarns(
DeprecationWarning):
result = sampler(circuits=[circuit], parameter_values=params)
def test_with_shots_option(self):
"""test with shots option."""
params, target = self._generate_params_target([1])
with self.assertWarns(DeprecationWarning):
sampler = Sampler(circuits=self._pqc)
result = sampler(circuits=[0],
parameter_values=params,
shots=1024,
seed=15)
self._compare_probs(result.quasi_dists, target)
def test_run_1qubit(self):
"""test for 1-qubit cases"""
qc = QuantumCircuit(1)
qc.measure_all()
qc2 = QuantumCircuit(1)
qc2.x(0)
qc2.measure_all()
sampler = Sampler()
result = sampler.run([qc, qc2]).result()
self.assertIsInstance(result, SamplerResult)
self.assertEqual(len(result.quasi_dists), 2)
keys, values = zip(*sorted(result.quasi_dists[0].items()))
self.assertTupleEqual(keys, tuple(range(2)))
np.testing.assert_allclose(values, [1, 0])
keys, values = zip(*sorted(result.quasi_dists[1].items()))
self.assertTupleEqual(keys, tuple(range(2)))
np.testing.assert_allclose(values, [0, 1])
def test_sampler_run_with_parameterized_circuits(self):
"""Test Sampler.run() with parameterized circuits."""
# parameterized circuit
pqc = self._pqc
pqc2 = self._pqc2
theta1, theta2, theta3 = self._theta
sampler = Sampler()
result = sampler.run([pqc, pqc, pqc2],
[theta1, theta2, theta3]).result()
# result of pqc(theta1)
prob1 = {
"00": 0.1309248462975777,
"01": 0.3608720796028448,
"10": 0.09324865232050054,
"11": 0.41495442177907715,
}
self.assertDictAlmostEqual(
result.quasi_dists[0].binary_probabilities(), prob1)
# result of pqc(theta2)
prob2 = {
"00": 0.06282290651933871,
"01": 0.02877144385576705,
"10": 0.606654494132085,
"11": 0.3017511554928094,
}
self.assertDictAlmostEqual(
result.quasi_dists[1].binary_probabilities(), prob2)
# result of pqc2(theta3)
prob3 = {
"00": 0.1880263994380416,
"01": 0.6881971261189544,
"10": 0.09326232720582443,
"11": 0.030514147237179892,
}
self.assertDictAlmostEqual(
result.quasi_dists[2].binary_probabilities(), prob3)
def test_run_empty_parameter(self):
"""Test for empty parameter"""
n = 5
qc = QuantumCircuit(n, n - 1)
qc.measure(range(n - 1), range(n - 1))
sampler = Sampler()
with self.subTest("one circuit"):
result = sampler.run([qc], shots=1000).result()
self.assertEqual(len(result.quasi_dists), 1)
for q_d in result.quasi_dists:
quasi_dist = {k: v for k, v in q_d.items() if v != 0.0}
self.assertDictEqual(quasi_dist, {0: 1.0})
self.assertEqual(len(result.metadata), 1)
with self.subTest("two circuits"):
result = sampler.run([qc, qc], shots=1000).result()
self.assertEqual(len(result.quasi_dists), 2)
for q_d in result.quasi_dists:
quasi_dist = {k: v for k, v in q_d.items() if v != 0.0}
self.assertDictEqual(quasi_dist, {0: 1.0})
self.assertEqual(len(result.metadata), 2)
def test_run_errors(self):
"""Test for errors"""
qc1 = QuantumCircuit(1)
qc1.measure_all()
qc2 = RealAmplitudes(num_qubits=1, reps=1)
qc2.measure_all()
sampler = Sampler()
with self.assertRaises(QiskitError):
sampler.run([qc1], [[1e2]]).result()
with self.assertRaises(QiskitError):
sampler.run([qc2], [[]]).result()
with self.assertRaises(QiskitError):
sampler.run([qc2], [[1e2]]).result()
def test_with_shots_option_none(self):
"""test with shots=None option. Seed is ignored then."""
with self.assertWarns(DeprecationWarning):
sampler = Sampler([self._pqc])
result_42 = sampler([0],
parameter_values=[[0, 1, 1, 2, 3, 5]],
shots=None,
seed=42)
result_15 = sampler([0],
parameter_values=[[0, 1, 1, 2, 3, 5]],
shots=None,
seed=15)
self.assertDictAlmostEqual(result_42.quasi_dists,
result_15.quasi_dists)
def test_errors(self):
"""Test for errors"""
qc1 = QuantumCircuit(1)
qc1.measure_all()
qc2 = RealAmplitudes(num_qubits=1, reps=1)
qc2.measure_all()
with Sampler([qc1, qc2], [qc1.parameters, qc2.parameters]) as sampler:
with self.assertRaises(QiskitError):
sampler([0], [[1e2]])
with self.assertRaises(QiskitError):
sampler([1], [[]])
with self.assertRaises(QiskitError):
sampler([1], [[1e2]])
def test_1qubit(self):
"""test for 1-qubit cases"""
qc = QuantumCircuit(1)
qc.measure_all()
qc2 = QuantumCircuit(1)
qc2.x(0)
qc2.measure_all()
with Sampler([qc, qc2], [qc.parameters, qc2.parameters]) as sampler:
result = sampler([0, 1], [[]] * 2)
self.assertIsInstance(result, SamplerResult)
self.assertEqual(len(result.quasi_dists), 2)
keys, values = zip(*sorted(result.quasi_dists[0].items()))
self.assertTupleEqual(keys, tuple(range(2)))
np.testing.assert_allclose(values, [1, 0])
keys, values = zip(*sorted(result.quasi_dists[1].items()))
self.assertTupleEqual(keys, tuple(range(2)))
np.testing.assert_allclose(values, [0, 1])
def test_2qubit(self):
"""test for 2-qubit cases"""
qc0 = QuantumCircuit(2)
qc0.measure_all()
qc1 = QuantumCircuit(2)
qc1.x(0)
qc1.measure_all()
qc2 = QuantumCircuit(2)
qc2.x(1)
qc2.measure_all()
qc3 = QuantumCircuit(2)
qc3.x([0, 1])
qc3.measure_all()
with self.assertWarns(DeprecationWarning):
sampler = Sampler(
[qc0, qc1, qc2, qc3],
[
qc0.parameters, qc1.parameters, qc2.parameters,
qc3.parameters
],
)
result = sampler([0, 1, 2, 3], [[]] * 4)
self.assertIsInstance(result, SamplerResult)
self.assertEqual(len(result.quasi_dists), 4)
keys, values = zip(*sorted(result.quasi_dists[0].items()))
self.assertTupleEqual(keys, tuple(range(4)))
np.testing.assert_allclose(values, [1, 0, 0, 0])
keys, values = zip(*sorted(result.quasi_dists[1].items()))
self.assertTupleEqual(keys, tuple(range(4)))
np.testing.assert_allclose(values, [0, 1, 0, 0])
keys, values = zip(*sorted(result.quasi_dists[2].items()))
self.assertTupleEqual(keys, tuple(range(4)))
np.testing.assert_allclose(values, [0, 0, 1, 0])
keys, values = zip(*sorted(result.quasi_dists[3].items()))
self.assertTupleEqual(keys, tuple(range(4)))
np.testing.assert_allclose(values, [0, 0, 0, 1])
def test_sampler_reverse_meas_order(self):
"""test for sampler with reverse measurement order"""
x = Parameter("x")
y = Parameter("y")
qc = QuantumCircuit(3, 3)
qc.rx(x, 0)
qc.rx(y, 1)
qc.x(2)
qc.measure(0, 2)
qc.measure(1, 1)
qc.measure(2, 0)
with self.assertWarns(DeprecationWarning):
sampler = Sampler([qc, qc], [[x, y], [y, x]])
result = sampler([0, 1, 0, 1],
[[0, 0], [0, 0], [np.pi / 2, 0], [np.pi / 2, 0]])
self.assertIsInstance(result, SamplerResult)
self.assertEqual(len(result.quasi_dists), 4)
# qc({x: 0, y: 0})
keys, values = zip(*sorted(result.quasi_dists[0].items()))
self.assertTupleEqual(keys, tuple(range(8)))
np.testing.assert_allclose(values, [0, 1, 0, 0, 0, 0, 0, 0])
# qc({x: 0, y: 0})
keys, values = zip(*sorted(result.quasi_dists[1].items()))
self.assertTupleEqual(keys, tuple(range(8)))
np.testing.assert_allclose(values, [0, 1, 0, 0, 0, 0, 0, 0])
# qc({x: pi/2, y: 0})
keys, values = zip(*sorted(result.quasi_dists[2].items()))
self.assertTupleEqual(keys, tuple(range(8)))
np.testing.assert_allclose(values, [0, 0.5, 0, 0, 0, 0.5, 0, 0])
# qc({x: 0, y: pi/2})
keys, values = zip(*sorted(result.quasi_dists[3].items()))
self.assertTupleEqual(keys, tuple(range(8)))
np.testing.assert_allclose(values, [0, 0.5, 0, 0.5, 0, 0, 0, 0])
def test_empty_parameter(self):
"""Test for empty parameter"""
n = 5
qc = QuantumCircuit(n, n - 1)
qc.measure(range(n - 1), range(n - 1))
with self.assertWarns(DeprecationWarning):
sampler = Sampler(circuits=[qc] * 10)
with self.subTest("one circuit"):
with self.assertWarns(DeprecationWarning):
result = sampler([0], shots=1000)
self.assertEqual(len(result.quasi_dists), 1)
for q_d in result.quasi_dists:
quasi_dist = {k: v for k, v in q_d.items() if v != 0.0}
self.assertDictEqual(quasi_dist, {0: 1.0})
self.assertEqual(len(result.metadata), 1)
with self.subTest("two circuits"):
with self.assertWarns(DeprecationWarning):
result = sampler([2, 4], shots=1000)
self.assertEqual(len(result.quasi_dists), 2)
for q_d in result.quasi_dists:
quasi_dist = {k: v for k, v in q_d.items() if v != 0.0}
self.assertDictEqual(quasi_dist, {0: 1.0})
self.assertEqual(len(result.metadata), 2)
def test_primitive_job_status_done(self):
"""test primitive job's status"""
bell = self._circuit[1]
sampler = Sampler()
job = sampler.run(circuits=[bell])
self.assertEqual(job.status(), JobStatus.DONE)
def test_sampler(self, indices):
"""test for sampler"""
circuits, target = self._generate_circuits_target(indices)
with Sampler(circuits=circuits) as sampler:
result = sampler(parameter_values=[[] for _ in indices])
self._compare_probs(result.quasi_dists, target)
def test_sampler_pqc(self, indices):
"""test for sampler with a parametrized circuit"""
params, target = self._generate_params_target(indices)
with Sampler(circuits=self._pqc) as sampler:
result = sampler([0] * len(params), params)
self._compare_probs(result.quasi_dists, target)
def test_sampler_example(self):
"""test for Sampler example"""
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
bell.measure_all()
# executes a Bell circuit
with self.assertWarns(DeprecationWarning):
sampler = Sampler(circuits=[bell], parameters=[[]])
result = sampler(parameter_values=[[]], circuits=[0])
self.assertIsInstance(result, SamplerResult)
self.assertEqual(len(result.quasi_dists), 1)
keys, values = zip(*sorted(result.quasi_dists[0].items()))
self.assertTupleEqual(keys, tuple(range(4)))
np.testing.assert_allclose(values, [0.5, 0, 0, 0.5])
self.assertEqual(len(result.metadata), 1)
# executes three Bell circuits
with self.assertWarns(DeprecationWarning):
sampler = Sampler([bell] * 3, [[]] * 3)
result = sampler([0, 1, 2], [[]] * 3)
self.assertIsInstance(result, SamplerResult)
self.assertEqual(len(result.quasi_dists), 3)
self.assertEqual(len(result.metadata), 3)
for dist in result.quasi_dists:
keys, values = zip(*sorted(dist.items()))
self.assertTupleEqual(keys, tuple(range(4)))
np.testing.assert_allclose(values, [0.5, 0, 0, 0.5])
with self.assertWarns(DeprecationWarning):
sampler = Sampler([bell])
result = sampler([bell, bell, bell])
self.assertIsInstance(result, SamplerResult)
self.assertEqual(len(result.quasi_dists), 3)
self.assertEqual(len(result.metadata), 3)
for dist in result.quasi_dists:
keys, values = zip(*sorted(dist.items()))
self.assertTupleEqual(keys, tuple(range(4)))
np.testing.assert_allclose(values, [0.5, 0, 0, 0.5])
# parametrized circuit
pqc = RealAmplitudes(num_qubits=2, reps=2)
pqc.measure_all()
pqc2 = RealAmplitudes(num_qubits=2, reps=3)
pqc2.measure_all()
theta1 = [0, 1, 1, 2, 3, 5]
theta2 = [1, 2, 3, 4, 5, 6]
theta3 = [0, 1, 2, 3, 4, 5, 6, 7]
with self.assertWarns(DeprecationWarning):
sampler = Sampler(circuits=[pqc, pqc2],
parameters=[pqc.parameters, pqc2.parameters])
result = sampler([0, 0, 1], [theta1, theta2, theta3])
self.assertIsInstance(result, SamplerResult)
self.assertEqual(len(result.quasi_dists), 3)
self.assertEqual(len(result.metadata), 3)
keys, values = zip(*sorted(result.quasi_dists[0].items()))
self.assertTupleEqual(keys, tuple(range(4)))
np.testing.assert_allclose(
values,
[
0.13092484629757767, 0.3608720796028449, 0.09324865232050054,
0.414954421779077
],
)
keys, values = zip(*sorted(result.quasi_dists[1].items()))
self.assertTupleEqual(keys, tuple(range(4)))
np.testing.assert_allclose(
values,
[
0.06282290651933871, 0.02877144385576703, 0.606654494132085,
0.3017511554928095
],
)
keys, values = zip(*sorted(result.quasi_dists[2].items()))
self.assertTupleEqual(keys, tuple(range(4)))
np.testing.assert_allclose(
values,
[
0.18802639943804164,
0.6881971261189544,
0.09326232720582446,
0.030514147237179882,
],
)