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_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_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 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 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 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_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_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)