def test_ee(self): """ EE test """ dummy_operator = MatrixOperator([[1]]) ee = NumPyMinimumEigensolver() output = ee.compute_minimum_eigenvalue(self.qubit_op) self.assertAlmostEqual(output.eigenvalue, -1.85727503)
def setUp(self): super().setUp() try: self.molecule = "H 0.000000 0.000000 0.735000;H 0.000000 0.000000 0.000000" self.driver = PySCFDriver(atom=self.molecule, unit=UnitsType.ANGSTROM, charge=0, spin=0, basis='631g') self.qmolecule = self.driver.run() self.core = Hamiltonian(transformation=TransformationType.FULL, qubit_mapping=QubitMappingType.PARITY, two_qubit_reduction=True, freeze_core=True, orbital_reduction=[]) self.qubit_op, _ = self.core.run(self.qmolecule) z2_symmetries = Z2Symmetries.find_Z2_symmetries(self.qubit_op) tapered_ops = z2_symmetries.taper(self.qubit_op) smallest_eig_value = 99999999999999 smallest_idx = -1 for idx, _ in enumerate(tapered_ops): ee = NumPyMinimumEigensolver(tapered_ops[idx]) curr_value = ee.compute_minimum_eigenvalue().eigenvalue.real if curr_value < smallest_eig_value: smallest_eig_value = curr_value smallest_idx = idx self.the_tapered_op = tapered_ops[smallest_idx] self.reference_energy_pUCCD = -1.1434447924298028 self.reference_energy_UCCD0 = -1.1476045878481704 self.reference_energy_UCCD0full = -1.1515491334334347 # reference energy of UCCSD/VQE with tapering everywhere self.reference_energy_UCCSD = -1.1516142309717594 # reference energy of UCCSD/VQE when no tapering on excitations is used self.reference_energy_UCCSD_no_tap_exc = -1.1516142309717594 # excitations for succ self.reference_singlet_double_excitations = [[0, 1, 4, 5], [0, 1, 4, 6], [0, 1, 4, 7], [0, 2, 4, 6], [0, 2, 4, 7], [0, 3, 4, 7]] # groups for succ_full self.reference_singlet_groups = [[[0, 1, 4, 5]], [[0, 1, 4, 6], [0, 2, 4, 5]], [[0, 1, 4, 7], [0, 3, 4, 5]], [[0, 2, 4, 6]], [[0, 2, 4, 7], [0, 3, 4, 6]], [[0, 3, 4, 7]]] except QiskitChemistryError: self.skipTest('PYSCF driver does not appear to be installed')
def test_no_symmetry(self): """ No symmetry reduction """ core = Hamiltonian(transformation=TransformationType.FULL, qubit_mapping=QubitMappingType.JORDAN_WIGNER, two_qubit_reduction=False, freeze_core=False, orbital_reduction=None, z2symmetry_reduction=None) qubit_op, aux_ops = core.run(self.qmolecule) self.assertEqual(qubit_op.num_qubits, 12) npme = NumPyMinimumEigensolver(qubit_op, aux_operators=aux_ops) result = core.process_algorithm_result(npme.compute_minimum_eigenvalue()) self._validate_result(result, False)
def test_given_symmetry(self): """ Supplied symmetry reduction """ core = Hamiltonian(transformation=TransformationType.FULL, qubit_mapping=QubitMappingType.JORDAN_WIGNER, two_qubit_reduction=False, freeze_core=False, orbital_reduction=None, z2symmetry_reduction=[1, 1, 1, 1]) qubit_op, aux_ops = core.run(self.qmolecule) self.assertEqual(qubit_op.num_qubits, 8) npme = NumPyMinimumEigensolver(qubit_op, aux_operators=aux_ops) result = core.process_algorithm_result(npme.compute_minimum_eigenvalue()) self._validate_result(result) self.assertEqual(core.molecule_info[core.INFO_Z2SYMMETRIES].tapering_values, [1, 1, 1, 1])
def test_auto_ph_freeze_core_parity_2(self): """ Auto symmetry reduction, with freeze core, parity and two q reduction """ core = Hamiltonian(transformation=TransformationType.PARTICLE_HOLE, qubit_mapping=QubitMappingType.PARITY, two_qubit_reduction=True, freeze_core=True, orbital_reduction=None, z2symmetry_reduction='auto') qubit_op, aux_ops = core.run(self.qmolecule) self.assertEqual(qubit_op.num_qubits, 6) npme = NumPyMinimumEigensolver(qubit_op, aux_operators=aux_ops) result = core.process_algorithm_result(npme.compute_minimum_eigenvalue()) self._validate_result(result) self.assertEqual(core.molecule_info[core.INFO_Z2SYMMETRIES].tapering_values, [1, 1])
def _run_driver(driver, transformation=TransformationType.FULL, qubit_mapping=QubitMappingType.JORDAN_WIGNER, two_qubit_reduction=False, freeze_core=True): qmolecule = driver.run() core = Hamiltonian(transformation=transformation, qubit_mapping=qubit_mapping, two_qubit_reduction=two_qubit_reduction, freeze_core=freeze_core, orbital_reduction=[]) qubit_op, aux_ops = core.run(qmolecule) npme = NumPyMinimumEigensolver(qubit_op, aux_operators=aux_ops) result = core.process_algorithm_result( npme.compute_minimum_eigenvalue()) return result
def test_cme_reuse(self): """ Test reuse """ # Start with no operator or aux_operators, give via compute method algo = NumPyMinimumEigensolver() result = algo.compute_minimum_eigenvalue(self.qubit_op) self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j) self.assertEqual(self.qubit_op, algo.operator) self.assertIsNone(result.aux_operator_eigenvalues) # Set operator to None and go again algo.operator = None with self.assertRaises(AquaError): _ = algo.run() # Set operator back as it was and go again algo.operator = self.qubit_op result = algo.compute_minimum_eigenvalue() self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j) self.assertIsNone(result.aux_operator_eigenvalues) # Add aux_operators and go again result = algo.compute_minimum_eigenvalue(aux_operators=self.aux_ops) self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j) self.assertEqual(len(result.aux_operator_eigenvalues), 2) np.testing.assert_array_almost_equal( result.aux_operator_eigenvalues[0], [2, 0]) np.testing.assert_array_almost_equal( result.aux_operator_eigenvalues[1], [0, 0]) # "Remove" aux_operators and go again result = algo.compute_minimum_eigenvalue(aux_operators=[]) self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j) self.assertIsNone(result.aux_operator_eigenvalues) # Set aux_operators and go again algo.aux_operators = self.aux_ops result = algo.compute_minimum_eigenvalue() self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j) self.assertEqual(len(result.aux_operator_eigenvalues), 2) np.testing.assert_array_almost_equal( result.aux_operator_eigenvalues[0], [2, 0]) np.testing.assert_array_almost_equal( result.aux_operator_eigenvalues[1], [0, 0]) np.testing.assert_array_equal(self.aux_ops, algo.aux_operators) # Finally just set one of aux_operators and main operator, remove aux_operators result = algo.compute_minimum_eigenvalue(self.aux_ops[0], []) self.assertAlmostEqual(result.eigenvalue, 2 + 0j) self.assertIsNone(result.aux_operator_eigenvalues)
def test_auto_symmetry(self): """ Auto symmetry reduction """ warnings.filterwarnings('ignore', category=DeprecationWarning) core = Hamiltonian(transformation=TransformationType.FULL, qubit_mapping=QubitMappingType.JORDAN_WIGNER, two_qubit_reduction=False, freeze_core=False, orbital_reduction=None, z2symmetry_reduction='auto') warnings.filterwarnings('always', category=DeprecationWarning) qubit_op, aux_ops = core.run(self.qmolecule) self.assertEqual(qubit_op.num_qubits, 8) npme = NumPyMinimumEigensolver(qubit_op, aux_operators=aux_ops) warnings.filterwarnings('ignore', category=DeprecationWarning) result = core.process_algorithm_result( npme.compute_minimum_eigenvalue()) warnings.filterwarnings('always', category=DeprecationWarning) self._validate_result(result) self.assertEqual( core.molecule_info[core.INFO_Z2SYMMETRIES].tapering_values, [1, 1, 1, 1])