def test_simplification(self):
""" Test Hamiltonians produce same result after simplification by constructor """
q = QuantumRegister(2, name='q')
qc = QuantumCircuit(q)
qc.rx(10.9891251356965, 0)
qc.rx(6.286692023269373, 1)
qc.rz(7.848801398269382, 0)
qc.rz(9.42477796076938, 1)
qc.cx(0, 1)
def eval_op(op):
from qiskit import execute
backend = BasicAer.get_backend('qasm_simulator')
evaluation_circuits = op.construct_evaluation_circuit(qc, False)
job = execute(evaluation_circuits, backend, shots=1024)
return op.evaluate_with_result(job.result(), False)
pauli_string = [[1.0, Pauli('XX')], [-1.0, Pauli('YY')],
[-1.0, Pauli('ZZ')]]
wpo = WeightedPauliOperator(pauli_string)
expectation_value, _ = eval_op(wpo)
self.assertAlmostEqual(expectation_value, -3.0, places=2)
# Half each coefficient value but double up (6 Paulis total)
pauli_string = [[0.5, Pauli('XX')], [-0.5, Pauli('YY')],
[-0.5, Pauli('ZZ')]]
pauli_string *= 2
wpo2 = WeightedPauliOperator(pauli_string)
expectation_value, _ = eval_op(wpo2)
self.assertAlmostEqual(expectation_value, -3.0, places=2)
def test_simplify(self):
""" simplify test """
pauli_a = 'IXYZ'
pauli_b = 'IXYZ'
coeff_a = 0.5
coeff_b = -0.5
pauli_term_a = [coeff_a, Pauli(pauli_a)]
pauli_term_b = [coeff_b, Pauli(pauli_b)]
op_a = WeightedPauliOperator(paulis=[pauli_term_a])
op_b = WeightedPauliOperator(paulis=[pauli_term_b])
new_op = op_a + op_b
new_op.simplify()
self.assertEqual(0, len(new_op.paulis),
"{}".format(new_op.print_details()))
self.assertTrue(new_op.is_empty())
paulis = [
Pauli(x) for x in ['IXYZ', 'XXZY', 'IIZZ', 'XXYY', 'ZZXX', 'YYYY']
]
coeffs = [0.2, 0.6, 0.8, -0.2, -0.6, -0.8]
op1 = WeightedPauliOperator.from_list(paulis, coeffs)
for i, pauli in enumerate(paulis):
tmp_op = WeightedPauliOperator(paulis=[[-coeffs[i], pauli]])
op1 += tmp_op
op1.simplify()
self.assertEqual(len(paulis) - (i + 1), len(op1.paulis))
def test_simplify_same_paulis(self):
""" simplify same paulis test """
pauli_a = 'IXYZ'
pauli_b = 'IXYZ'
coeff_a = 0.5
coeff_b = 0.5
pauli_term_a = [coeff_a, Pauli(pauli_a)]
pauli_term_b = [coeff_b, Pauli(pauli_b)]
op_a = WeightedPauliOperator(paulis=[pauli_term_a, pauli_term_b])
self.assertEqual(1, len(op_a.paulis),
"{}".format(op_a.print_details()))
self.assertEqual(1, len(op_a.basis))
self.assertEqual(0, op_a.basis[0][1][0])
def test_negation_operator(self):
""" negation operator test """
paulis = [
Pauli(x) for x in ['IXYZ', 'XXZY', 'IIZZ', 'XXYY', 'ZZXX', 'YYYY']
]
coeffs = [0.2, 0.6, 0.8, -0.2, -0.6, -0.8]
op1 = WeightedPauliOperator.from_list(paulis, coeffs)
coeffs = [-0.2, -0.6, -0.8, 0.2, 0.6, 0.8]
op2 = WeightedPauliOperator.from_list(paulis, coeffs)
self.assertNotEqual(op1, op2)
self.assertEqual(op1, -op2)
self.assertEqual(-op1, op2)
op1 = op1 * -1.0
self.assertEqual(op1, op2)
def test_to_opflow(self):
"""Test for to_opflow() in WeightedPauliOperator"""
pauli_a = 'IXYZ'
pauli_b = 'ZYIX'
coeff_a = 0.5 + 1j
coeff_b = -0.5 - 1j
pauli_term_a = [coeff_a, Pauli(pauli_a)]
pauli_term_b = [coeff_b, Pauli(pauli_b)]
op_a = WeightedPauliOperator(paulis=[pauli_term_a])
op_b = WeightedPauliOperator(paulis=[pauli_term_b])
legacy_op = op_a + op_b
op = coeff_a * (I ^ X ^ Y ^ Z) + coeff_b * (Z ^ Y ^ I ^ X)
self.assertEqual(op, legacy_op.to_opflow())
def test_sub(self):
""" sub test """
pauli_a = 'IXYZ'
pauli_b = 'ZYIX'
coeff_a = 0.5
coeff_b = 0.5
pauli_term_a = [coeff_a, Pauli(pauli_a)]
pauli_term_b = [coeff_b, Pauli(pauli_b)]
op_a = WeightedPauliOperator(paulis=[pauli_term_a])
op_b = WeightedPauliOperator(paulis=[pauli_term_b])
ori_op_a = op_a.copy()
ori_op_b = op_b.copy()
new_op = op_a - op_b
self.assertEqual(op_a, ori_op_a)
self.assertEqual(op_b, ori_op_b)
self.assertEqual(1, len(op_a.paulis))
self.assertEqual(2, len(new_op.paulis))
self.assertEqual(0.5, new_op.paulis[0][0])
self.assertEqual(-0.5, new_op.paulis[1][0])
pauli_c = 'IXYZ'
coeff_c = 0.25
pauli_term_c = [coeff_c, Pauli(pauli_c)]
new_op = new_op - WeightedPauliOperator(paulis=[pauli_term_c])
self.assertEqual(2, len(new_op.paulis))
self.assertEqual(0.25, new_op.paulis[0][0])
def test_iadd(self):
""" iadd test """
pauli_a = 'IXYZ'
pauli_b = 'ZYIX'
coeff_a = 0.5
coeff_b = 0.5
pauli_term_a = [coeff_a, Pauli(pauli_a)]
pauli_term_b = [coeff_b, Pauli(pauli_b)]
op_a = WeightedPauliOperator(paulis=[pauli_term_a])
op_b = WeightedPauliOperator(paulis=[pauli_term_b])
ori_op_a = op_a.copy()
ori_op_b = op_b.copy()
op_a += op_b
self.assertNotEqual(op_a, ori_op_a)
self.assertEqual(op_b, ori_op_b)
self.assertEqual(2, len(op_a.paulis))
pauli_c = 'IXYZ'
coeff_c = 0.25
pauli_term_c = [coeff_c, Pauli(pauli_c)]
op_a += WeightedPauliOperator(paulis=[pauli_term_c])
self.assertEqual(2, len(op_a.paulis))
self.assertEqual(0.75, op_a.paulis[0][0])
def test_from_to_file(self):
""" from to file test """
paulis = [
Pauli(x) for x in ['IXYZ', 'XXZY', 'IIZZ', 'XXYY', 'ZZXX', 'YYYY']
]
weights = [
0.2 + -1j * 0.8, 0.6 + -1j * 0.6, 0.8 + -1j * 0.2,
-0.2 + -1j * 0.8, -0.6 - -1j * 0.6, -0.8 - -1j * 0.2
]
op = WeightedPauliOperator.from_list(paulis, weights)
file_path = self._get_resource_path('temp_op.json')
op.to_file(file_path)
self.assertTrue(os.path.exists(file_path))
try:
load_op = WeightedPauliOperator.from_file(file_path)
self.assertEqual(op, load_op)
finally:
os.remove(file_path)
def test_str(self):
""" str test """
pauli_a = 'IXYZ'
pauli_b = 'ZYIX'
coeff_a = 0.5
coeff_b = 0.5
pauli_term_a = [coeff_a, Pauli(pauli_a)]
pauli_term_b = [coeff_b, Pauli(pauli_b)]
op_a = WeightedPauliOperator(paulis=[pauli_term_a])
op_b = WeightedPauliOperator(paulis=[pauli_term_b])
op_a += op_b
self.assertEqual("Representation: paulis, qubits: 4, size: 2",
str(op_a))
op_a = WeightedPauliOperator(paulis=[pauli_term_a], name='ABC')
self.assertEqual("ABC: Representation: paulis, qubits: 4, size: 1",
str(op_a))
def setUp(self):
super().setUp()
pauli_dict = {
'paulis': [{"coeff": {"imag": 0.0, "real": -1.052373245772859}, "label": "II"},
{"coeff": {"imag": 0.0, "real": 0.39793742484318045}, "label": "ZI"},
{"coeff": {"imag": 0.0, "real": -0.39793742484318045}, "label": "IZ"},
{"coeff": {"imag": 0.0, "real": -0.01128010425623538}, "label": "ZZ"},
{"coeff": {"imag": 0.0, "real": 0.18093119978423156}, "label": "XX"}
]
}
self.qubit_op = WeightedPauliOperator.from_dict(pauli_dict).to_opflow()
def test_equal_operator(self):
""" equal operator test """
paulis = [
Pauli(x) for x in ['IXYZ', 'XXZY', 'IIZZ', 'XXYY', 'ZZXX', 'YYYY']
]
coeffs = [0.2, 0.6, 0.8, -0.2, -0.6, -0.8]
op1 = WeightedPauliOperator.from_list(paulis, coeffs)
coeffs = [0.2, 0.6, 0.8, -0.2, -0.6, -0.8]
op2 = WeightedPauliOperator.from_list(paulis, coeffs)
coeffs = [-0.2, -0.6, -0.8, 0.2, 0.6, 0.8]
op3 = WeightedPauliOperator.from_list(paulis, coeffs)
coeffs = [-0.2, 0.6, 0.8, -0.2, -0.6, -0.8]
op4 = WeightedPauliOperator.from_list(paulis, coeffs)
self.assertEqual(op1, op2)
self.assertNotEqual(op1, op3)
self.assertNotEqual(op1, op4)
self.assertNotEqual(op3, op4)
def test_multiplication(self):
""" multiplication test """
pauli_a = 'IXYZ'
pauli_b = 'ZYIX'
coeff_a = 0.5
coeff_b = 0.5
pauli_term_a = [coeff_a, Pauli(pauli_a)]
pauli_term_b = [coeff_b, Pauli(pauli_b)]
op_a = WeightedPauliOperator(paulis=[pauli_term_a])
op_b = WeightedPauliOperator(paulis=[pauli_term_b])
new_op = op_a * op_b
self.assertEqual(1, len(new_op.paulis))
self.assertEqual(0.25, new_op.paulis[0][0])
self.assertEqual('-ZZYY', new_op.paulis[0][1].to_label())
new_op = -2j * new_op
self.assertEqual(-0.5j, new_op.paulis[0][0])
new_op = new_op * 0.3j
self.assertEqual(0.15, new_op.paulis[0][0])
def setUp(self):
super().setUp()
seed = 0
aqua_globals.random_seed = seed
self.num_qubits = 2
m_size = np.power(2, self.num_qubits)
matrix = aqua_globals.random.random((m_size, m_size))
self.mat_op = MatrixOperator(matrix=matrix)
paulis = [Pauli("".join(pauli_label))
for pauli_label in itertools.product('IXYZ', repeat=self.num_qubits)]
weights = aqua_globals.random.random(len(paulis))
self.pauli_op = WeightedPauliOperator.from_list(paulis, weights)
def setUp(self):
""" Set the problem. """
super().setUp()
aqua_globals.random_seed = 50
pauli_dict = {
'paulis': [{"coeff": {"imag": 0.0, "real": -1.052373245772859}, "label": "II"},
{"coeff": {"imag": 0.0, "real": 0.39793742484318045}, "label": "IZ"},
{"coeff": {"imag": 0.0, "real": -0.39793742484318045}, "label": "ZI"},
{"coeff": {"imag": 0.0, "real": -0.01128010425623538}, "label": "ZZ"},
{"coeff": {"imag": 0.0, "real": 0.18093119978423156}, "label": "XX"}
]
}
self.qubit_op = WeightedPauliOperator.from_dict(pauli_dict)
def setUp(self):
super().setUp()
seed = 1
aqua_globals.random_seed = seed
self.num_qubits = 3
paulis = [Pauli.from_label(pauli_label)
for pauli_label in itertools.product('IXYZ', repeat=self.num_qubits)]
weights = aqua_globals.random.random(len(paulis))
self.qubit_op = WeightedPauliOperator.from_list(paulis, weights)
self.var_form = EfficientSU2(self.qubit_op.num_qubits, reps=1)
qasm_simulator = BasicAer.get_backend('qasm_simulator')
self.quantum_instance_qasm = QuantumInstance(qasm_simulator, shots=65536,
seed_simulator=seed, seed_transpiler=seed)
statevector_simulator = BasicAer.get_backend('statevector_simulator')
self.quantum_instance_statevector = \
QuantumInstance(statevector_simulator, shots=1,
seed_simulator=seed, seed_transpiler=seed)
def test_unsorted_grouping(self):
"""Test with normal grouping approach."""
num_qubits = 4
paulis = [Pauli.from_label(pauli_label)
for pauli_label in itertools.product('IXYZ', repeat=num_qubits)]
weights = aqua_globals.random.random(len(paulis))
op = WeightedPauliOperator.from_list(paulis, weights)
grouped_op = op_converter.to_tpb_grouped_weighted_pauli_operator(
op, TPBGroupedWeightedPauliOperator.unsorted_grouping)
for g_p in grouped_op.paulis:
passed = False
for pauli in op.paulis:
if pauli[1] == g_p[1]:
passed = pauli[0] == g_p[0]
break
self.assertTrue(passed,
"non-existed paulis in grouped_paulis: {}".format(g_p[1].to_label()))
self.assertGreaterEqual(len(op.basis), len(grouped_op.basis))
def test_chop_real(self):
""" chop real test """
paulis = [
Pauli(x) for x in ['IXYZ', 'XXZY', 'IIZZ', 'XXYY', 'ZZXX', 'YYYY']
]
coeffs = [0.2, 0.6, 0.8, -0.2, -0.6, -0.8]
op = WeightedPauliOperator.from_list(paulis, coeffs)
ori_op = op.copy()
for threshold, num_paulis in zip([0.4, 0.7, 0.9], [4, 2, 0]):
op = ori_op.copy()
op1 = op.chop(threshold=threshold, copy=True)
self.assertEqual(len(op.paulis), 6,
"\n{}".format(op.print_details()))
self.assertEqual(len(op1.paulis), num_paulis,
"\n{}".format(op1.print_details()))
op1 = op.chop(threshold=threshold, copy=False)
self.assertEqual(len(op.paulis), num_paulis,
"\n{}".format(op.print_details()))
self.assertEqual(len(op1.paulis), num_paulis,
"\n{}".format(op1.print_details()))
def test_legacy_operator(self):
"""Test the VQE accepts and converts the legacy WeightedPauliOperator."""
pauli_dict = {
'paulis': [{
"coeff": {
"imag": 0.0,
"real": -1.052373245772859
},
"label": "II"
}, {
"coeff": {
"imag": 0.0,
"real": 0.39793742484318045
},
"label": "IZ"
}, {
"coeff": {
"imag": 0.0,
"real": -0.39793742484318045
},
"label": "ZI"
}, {
"coeff": {
"imag": 0.0,
"real": -0.01128010425623538
},
"label": "ZZ"
}, {
"coeff": {
"imag": 0.0,
"real": 0.18093119978423156
},
"label": "XX"
}]
}
h2_op = WeightedPauliOperator.from_dict(pauli_dict)
vqe = VQE(h2_op)
self.assertEqual(vqe.operator, self.h2_op)
def test_sorted_grouping(self):
"""Test with color grouping approach."""
num_qubits = 2
paulis = [Pauli.from_label(pauli_label)
for pauli_label in itertools.product('IXYZ', repeat=num_qubits)]
weights = aqua_globals.random.random(len(paulis))
op = WeightedPauliOperator.from_list(paulis, weights)
grouped_op = op_converter.to_tpb_grouped_weighted_pauli_operator(
op, TPBGroupedWeightedPauliOperator.sorted_grouping)
# check all paulis are still existed.
for g_p in grouped_op.paulis:
passed = False
for pauli in op.paulis:
if pauli[1] == g_p[1]:
passed = pauli[0] == g_p[0]
break
self.assertTrue(passed,
"non-existed paulis in grouped_paulis: {}".format(g_p[1].to_label()))
# check the number of basis of grouped
# one should be less than and equal to the original one.
self.assertGreaterEqual(len(op.basis), len(grouped_op.basis))
def test_chop(self):
""" chop test """
paulis = [Pauli.from_label(x) for x in ['IIXX', 'ZZXX', 'ZZZZ', 'XXZZ', 'XXXX', 'IXXX']]
coeffs = [0.2, 0.3, 0.4, 0.5, 0.6, 0.7]
op = WeightedPauliOperator.from_list(paulis, coeffs)
grouped_op = op_converter.to_tpb_grouped_weighted_pauli_operator(
op, TPBGroupedWeightedPauliOperator.sorted_grouping)
original_num_basis = len(grouped_op.basis)
chopped_grouped_op = grouped_op.chop(0.35, copy=True)
self.assertLessEqual(len(chopped_grouped_op.basis), 3)
self.assertLessEqual(len(chopped_grouped_op.basis), original_num_basis)
# ZZXX group is remove
for b, _ in chopped_grouped_op.basis:
self.assertFalse(b.to_label() == 'ZZXX')
chopped_grouped_op = grouped_op.chop(0.55, copy=True)
self.assertLessEqual(len(chopped_grouped_op.basis), 1)
self.assertLessEqual(len(chopped_grouped_op.basis), original_num_basis)
for b, _ in chopped_grouped_op.basis:
self.assertFalse(b.to_label() == 'ZZXX')
self.assertFalse(b.to_label() == 'ZZZZ')
self.assertFalse(b.to_label() == 'XXZZ')
def test_isub(self):
""" isub test """
pauli_a = 'IXYZ'
pauli_b = 'ZYIX'
coeff_a = 0.5
coeff_b = 0.5
pauli_term_a = [coeff_a, Pauli(pauli_a)]
pauli_term_b = [coeff_b, Pauli(pauli_b)]
op_a = WeightedPauliOperator(paulis=[pauli_term_a])
op_b = WeightedPauliOperator(paulis=[pauli_term_b])
ori_op_a = op_a.copy()
ori_op_b = op_b.copy()
op_a -= op_b
self.assertNotEqual(op_a, ori_op_a)
self.assertEqual(op_b, ori_op_b)
self.assertEqual(2, len(op_a.paulis))
pauli_c = 'IXYZ'
coeff_c = 0.5
pauli_term_c = [coeff_c, Pauli(pauli_c)]
op_a -= WeightedPauliOperator(paulis=[pauli_term_c])
# sub does not remove zero weights.
self.assertEqual(2, len(op_a.paulis))
def setUp(self):
super().setUp()
pauli_dict = {
'paulis': [{
"coeff": {
"imag": 0.0,
"real": -1.052373245772859
},
"label": "II"
}, {
"coeff": {
"imag": 0.0,
"real": 0.39793742484318045
},
"label": "ZI"
}, {
"coeff": {
"imag": 0.0,
"real": -0.39793742484318045
},
"label": "IZ"
}, {
"coeff": {
"imag": 0.0,
"real": -0.01128010425623538
},
"label": "ZZ"
}, {
"coeff": {
"imag": 0.0,
"real": 0.18093119978423156
},
"label": "XX"
}]
}
self.qubit_op = WeightedPauliOperator.from_dict(pauli_dict).to_opflow()
aux_dict_1 = {
'paulis': [{
'coeff': {
'imag': 0.0,
'real': 2.0
},
'label': 'II'
}]
}
aux_dict_2 = {
'paulis': [{
'coeff': {
'imag': 0.0,
'real': 0.5
},
'label': 'II'
}, {
'coeff': {
'imag': 0.0,
'real': 0.5
},
'label': 'ZZ'
}, {
'coeff': {
'imag': 0.0,
'real': 0.5
},
'label': 'YY'
}, {
'coeff': {
'imag': 0.0,
'real': -0.5
},
'label': 'XX'
}]
}
self.aux_ops = [
WeightedPauliOperator.from_dict(aux_dict_1).to_opflow(),
WeightedPauliOperator.from_dict(aux_dict_2).to_opflow()
]
def test_is_empty(self):
""" is empty test """
op = WeightedPauliOperator(paulis=[])
self.assertTrue(op.is_empty())
self.assertFalse(self.qubit_op.is_empty())
def test_num_qubits(self):
""" num qubits test """
op = WeightedPauliOperator(paulis=[])
self.assertEqual(op.num_qubits, 0)
self.assertEqual(self.qubit_op.num_qubits, self.num_qubits)
def test_evaluate_single_pauli_statevector(self):
""" evaluate single pauli statevector test """
# X
op = WeightedPauliOperator.from_list([Pauli('X')])
qr = QuantumRegister(1, name='q')
wave_function = QuantumCircuit(qr)
# + 1 eigenstate
wave_function.h(qr[0])
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=True)
result = self.quantum_instance_statevector.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=True)
self.assertAlmostEqual(1.0, actual_value[0].real, places=5)
# - 1 eigenstate
wave_function = QuantumCircuit(qr)
wave_function.x(qr[0])
wave_function.h(qr[0])
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=True)
result = self.quantum_instance_statevector.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=True)
self.assertAlmostEqual(-1.0, actual_value[0].real, places=5)
# Y
op = WeightedPauliOperator.from_list([Pauli('Y')])
qr = QuantumRegister(1, name='q')
wave_function = QuantumCircuit(qr)
# + 1 eigenstate
wave_function.h(qr[0])
wave_function.s(qr[0])
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=True)
result = self.quantum_instance_statevector.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=True)
self.assertAlmostEqual(1.0, actual_value[0].real, places=5)
# - 1 eigenstate
wave_function = QuantumCircuit(qr)
wave_function.x(qr[0])
wave_function.h(qr[0])
wave_function.s(qr[0])
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=True)
result = self.quantum_instance_statevector.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=True)
self.assertAlmostEqual(-1.0, actual_value[0].real, places=5)
# Z
op = WeightedPauliOperator.from_list([Pauli('Z')])
qr = QuantumRegister(1, name='q')
wave_function = QuantumCircuit(qr)
# + 1 eigenstate
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=True)
result = self.quantum_instance_statevector.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=True)
self.assertAlmostEqual(1.0, actual_value[0].real, places=5)
# - 1 eigenstate
wave_function = QuantumCircuit(qr)
wave_function.x(qr[0])
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=True)
result = self.quantum_instance_statevector.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=True)
self.assertAlmostEqual(-1.0, actual_value[0].real, places=5)
