def test_second_q_ops_with_active_space(self): """Tests that the correct second quantized operator is created if an active space transformer is provided.""" expected_num_of_sec_quant_ops = 7 expected_fermionic_op_path = self.get_resource_path( 'H2_631g_ferm_op_active_space', 'problems/second_quantization/' 'electronic/resources') expected_fermionic_op = read_expected_file(expected_fermionic_op_path) driver = HDF5Driver( hdf5_input=self.get_resource_path('H2_631g.hdf5', 'transformers')) trafo = ActiveSpaceTransformer(num_electrons=2, num_molecular_orbitals=2) electronic_structure_problem = ElectronicStructureProblem( driver, [trafo]) second_quantized_ops = electronic_structure_problem.second_q_ops() electr_sec_quant_op = second_quantized_ops[0] with self.subTest( "Check expected length of the list of second quantized operators." ): assert len(second_quantized_ops) == expected_num_of_sec_quant_ops with self.subTest( "Check types in the list of second quantized operators."): for second_quantized_op in second_quantized_ops: assert isinstance(second_quantized_op, SecondQuantizedOp) with self.subTest( "Check components of electronic second quantized operator."): assert all(s[0] == t[0] and np.isclose(s[1], t[1]) for s, t in zip( expected_fermionic_op, electr_sec_quant_op.to_list()))
def test_second_q_ops_without_transformers(self): """Tests that the list of second quantized operators is created if no transformers provided.""" expected_num_of_sec_quant_ops = 7 expected_fermionic_op_path = self.get_resource_path( "H2_631g_ferm_op_two_ints", "problems/second_quantization/electronic/resources", ) expected_fermionic_op = read_expected_file(expected_fermionic_op_path) driver = HDF5Driver(hdf5_input=self.get_resource_path("H2_631g.hdf5", "transformers")) electronic_structure_problem = ElectronicStructureProblem(driver) second_quantized_ops = electronic_structure_problem.second_q_ops() electr_sec_quant_op = second_quantized_ops[0] with self.subTest("Check expected length of the list of second quantized operators."): assert len(second_quantized_ops) == expected_num_of_sec_quant_ops with self.subTest("Check types in the list of second quantized operators."): for second_quantized_op in second_quantized_ops: assert isinstance(second_quantized_op, SecondQuantizedOp) with self.subTest("Check components of electronic second quantized operator."): assert all( s[0] == t[0] and np.isclose(s[1], t[1]) for s, t in zip(expected_fermionic_op, electr_sec_quant_op.to_list()) )
def test_second_q_ops_with_active_space(self): """Tests that the correct second quantized operator is created if an active space transformer is provided.""" expected_num_of_sec_quant_ops = 7 expected_fermionic_op_path = self.get_resource_path( "H2_631g_ferm_op_active_space", "problems/second_quantization/electronic/resources", ) expected_fermionic_op = read_expected_file(expected_fermionic_op_path) with warnings.catch_warnings(): warnings.filterwarnings("ignore", category=DeprecationWarning) driver = LegacyHDF5Driver(hdf5_input=self.get_resource_path( "H2_631g.hdf5", "transformers/second_quantization/electronic")) trafo = LegacyActiveSpaceTransformer(num_electrons=2, num_molecular_orbitals=2) electronic_structure_problem = ElectronicStructureProblem( driver, [trafo]) second_quantized_ops = electronic_structure_problem.second_q_ops() electr_sec_quant_op = second_quantized_ops[0] with self.subTest("Check that the correct properties are/aren't None"): with warnings.catch_warnings(): warnings.filterwarnings("ignore", category=DeprecationWarning) # legacy driver used, molecule_data should not be None self.assertIsNotNone( electronic_structure_problem.molecule_data) # transformer used, molecule_data_transformed should not be None self.assertIsNotNone( electronic_structure_problem.molecule_data_transformed) # converted properties should never be None self.assertIsNotNone(electronic_structure_problem.grouped_property) self.assertIsNotNone( electronic_structure_problem.grouped_property_transformed) with self.subTest( "Check that the deprecated molecule_data property is not None" ): with warnings.catch_warnings(): warnings.filterwarnings("ignore", category=DeprecationWarning) self.assertIsNotNone( electronic_structure_problem.molecule_data) with self.subTest( "Check expected length of the list of second quantized operators." ): assert len(second_quantized_ops) == expected_num_of_sec_quant_ops with self.subTest( "Check types in the list of second quantized operators."): for second_quantized_op in second_quantized_ops: assert isinstance(second_quantized_op, SecondQuantizedOp) with self.subTest( "Check components of electronic second quantized operator."): assert all(s[0] == t[0] and np.isclose(s[1], t[1]) for s, t in zip( expected_fermionic_op, electr_sec_quant_op.to_list()))
def test_molecular_problem_sector_locator_z2_symmetry(self): """ Test mapping to qubit operator with z2 symmetry tapering and two qubit reduction """ driver = HDF5Driver(hdf5_input=self.get_resource_path( 'test_driver_hdf5.hdf5', 'drivers/hdf5d')) problem = ElectronicStructureProblem(driver) mapper = JordanWignerMapper() qubit_conv = QubitConverter(mapper, two_qubit_reduction=True, z2symmetry_reduction='auto') qubit_op = qubit_conv.convert( problem.second_q_ops()[0], self.num_particles, sector_locator=problem.symmetry_sector_locator) self.assertEqual(qubit_op, TestQubitConverter.REF_H2_JW_TAPERED)
def test_sector_locator_h2o(self): """Test sector locator.""" driver = PySCFDriver( atom= "O 0.0000 0.0000 0.1173; H 0.0000 0.07572 -0.4692;H 0.0000 -0.07572 -0.4692", basis="sto-3g", ) es_problem = ElectronicStructureProblem(driver) qubit_conv = QubitConverter(mapper=ParityMapper(), two_qubit_reduction=True, z2symmetry_reduction="auto") qubit_conv.convert( es_problem.second_q_ops()[0], num_particles=es_problem.num_particles, sector_locator=es_problem.symmetry_sector_locator, ) self.assertListEqual(qubit_conv.z2symmetries.tapering_values, [1, -1])
def test_excitation_preserving(self): """Test the excitation preserving wavefunction on a chemistry example.""" driver = HDF5Driver( self.get_resource_path("test_driver_hdf5.hdf5", "drivers/hdf5d")) converter = QubitConverter(ParityMapper()) problem = ElectronicStructureProblem(driver) _ = problem.second_q_ops() num_particles = ( problem.molecule_data_transformed.num_alpha, problem.molecule_data_transformed.num_beta, ) num_spin_orbitals = problem.molecule_data_transformed.num_molecular_orbitals * 2 optimizer = SLSQP(maxiter=100) initial_state = HartreeFock(num_spin_orbitals, num_particles, converter) wavefunction = ExcitationPreserving(num_spin_orbitals) wavefunction.compose(initial_state, front=True, inplace=True) solver = VQE( ansatz=wavefunction, optimizer=optimizer, quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator"), seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed, ), ) gsc = GroundStateEigensolver(converter, solver) result = gsc.solve(problem) self.assertAlmostEqual(result.total_energies[0], self.reference_energy, places=4)
def test_second_q_ops_without_transformers(self): """Tests that the list of second quantized operators is created if no transformers provided.""" expected_num_of_sec_quant_ops = 7 expected_fermionic_op_path = self.get_resource_path( "H2_631g_ferm_op_two_ints", "problems/second_quantization/electronic/resources", ) expected_fermionic_op = read_expected_file(expected_fermionic_op_path) driver = HDF5Driver(hdf5_input=self.get_resource_path( "H2_631g.hdf5", "transformers/second_quantization/electronic")) electronic_structure_problem = ElectronicStructureProblem(driver) second_quantized_ops = electronic_structure_problem.second_q_ops() electr_sec_quant_op = second_quantized_ops[ electronic_structure_problem.main_property_name] second_quantized_ops = list(second_quantized_ops.values()) with self.subTest("Check that the correct properties are/aren't None"): with warnings.catch_warnings(): warnings.filterwarnings("ignore", category=DeprecationWarning) # new driver used, molecule_data* should be None self.assertIsNone(electronic_structure_problem.molecule_data) self.assertIsNone( electronic_structure_problem.molecule_data_transformed) # converted properties should never be None self.assertIsNotNone(electronic_structure_problem.grouped_property) self.assertIsNotNone( electronic_structure_problem.grouped_property_transformed) with self.subTest( "Check expected length of the list of second quantized operators." ): assert len(second_quantized_ops) == expected_num_of_sec_quant_ops with self.subTest( "Check types in the list of second quantized operators."): for second_quantized_op in second_quantized_ops: assert isinstance(second_quantized_op, SecondQuantizedOp) with self.subTest( "Check components of electronic second quantized operator."): assert all(s[0] == t[0] and np.isclose(s[1], t[1]) for s, t in zip( expected_fermionic_op, electr_sec_quant_op.to_list()))
def test_sector_locator_homonuclear(self): """Test sector locator.""" molecule = Molecule(geometry=[("Li", [0.0, 0.0, 0.0]), ("Li", [0.0, 0.0, 2.771])], charge=0, multiplicity=1) freeze_core_transformer = FreezeCoreTransformer(True) driver = ElectronicStructureMoleculeDriver( molecule, basis="sto3g", driver_type=ElectronicStructureDriverType.PYSCF) es_problem = ElectronicStructureProblem( driver, transformers=[freeze_core_transformer]) qubit_conv = QubitConverter(mapper=ParityMapper(), two_qubit_reduction=True, z2symmetry_reduction="auto") qubit_conv.convert( es_problem.second_q_ops()[0], num_particles=es_problem.num_particles, sector_locator=es_problem.symmetry_sector_locator, ) self.assertListEqual(qubit_conv.z2symmetries.tapering_values, [-1, 1])
class TestHoppingOpsBuilder(QiskitNatureTestCase): """Tests Hopping Operators builder.""" def setUp(self): super().setUp() algorithm_globals.random_seed = 8 try: self.driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.75', unit=UnitsType.ANGSTROM, charge=0, spin=0, basis='sto3g') except QiskitNatureError: self.skipTest('PYSCF driver does not appear to be installed') self.qubit_converter = QubitConverter(JordanWignerMapper()) self.electronic_structure_problem = ElectronicStructureProblem( self.driver) self.electronic_structure_problem.second_q_ops() self.q_molecule = self.electronic_structure_problem.molecule_data def test_build_hopping_operators(self): """Tests that the correct hopping operator is built from QMolecule.""" # TODO extract it somewhere expected_hopping_operators = ({ 'E_0': PauliSumOp(SparsePauliOp( [[True, True, False, False, False, False, False, False], [True, True, False, False, False, True, False, False], [True, True, False, False, True, False, False, False], [True, True, False, False, True, True, False, False]], coeffs=[1. + 0.j, 0. - 1.j, 0. + 1.j, 1. + 0.j]), coeff=1.0), 'Edag_0': PauliSumOp(SparsePauliOp( [[True, True, False, False, False, False, False, False], [True, True, False, False, False, True, False, False], [True, True, False, False, True, False, False, False], [True, True, False, False, True, True, False, False]], coeffs=[-1. + 0.j, 0. - 1.j, 0. + 1.j, -1. + 0.j]), coeff=1.0), 'E_1': PauliSumOp(SparsePauliOp( [[False, False, True, True, False, False, False, False], [False, False, True, True, False, False, False, True], [False, False, True, True, False, False, True, False], [False, False, True, True, False, False, True, True]], coeffs=[1. + 0.j, 0. - 1.j, 0. + 1.j, 1. + 0.j]), coeff=1.0), 'Edag_1': PauliSumOp(SparsePauliOp( [[False, False, True, True, False, False, False, False], [False, False, True, True, False, False, False, True], [False, False, True, True, False, False, True, False], [False, False, True, True, False, False, True, True]], coeffs=[-1. + 0.j, 0. - 1.j, 0. + 1.j, -1. + 0.j]), coeff=1.0), 'E_2': PauliSumOp(SparsePauliOp( [[True, True, True, True, False, False, False, False], [True, True, True, True, False, False, False, True], [True, True, True, True, False, False, True, False], [True, True, True, True, False, False, True, True], [True, True, True, True, False, True, False, False], [True, True, True, True, False, True, False, True], [True, True, True, True, False, True, True, False], [True, True, True, True, False, True, True, True], [True, True, True, True, True, False, False, False], [True, True, True, True, True, False, False, True], [True, True, True, True, True, False, True, False], [True, True, True, True, True, False, True, True], [True, True, True, True, True, True, False, False], [True, True, True, True, True, True, False, True], [True, True, True, True, True, True, True, False], [True, True, True, True, True, True, True, True]], coeffs=[ 1. + 0.j, 0. - 1.j, 0. + 1.j, 1. + 0.j, 0. - 1.j, -1. + 0.j, 1. + 0.j, 0. - 1.j, 0. + 1.j, 1. + 0.j, -1. + 0.j, 0. + 1.j, 1. + 0.j, 0. - 1.j, 0. + 1.j, 1. + 0.j ]), coeff=1.0), 'Edag_2': PauliSumOp(SparsePauliOp( [[True, True, True, True, False, False, False, False], [True, True, True, True, False, False, False, True], [True, True, True, True, False, False, True, False], [True, True, True, True, False, False, True, True], [True, True, True, True, False, True, False, False], [True, True, True, True, False, True, False, True], [True, True, True, True, False, True, True, False], [True, True, True, True, False, True, True, True], [True, True, True, True, True, False, False, False], [True, True, True, True, True, False, False, True], [True, True, True, True, True, False, True, False], [True, True, True, True, True, False, True, True], [True, True, True, True, True, True, False, False], [True, True, True, True, True, True, False, True], [True, True, True, True, True, True, True, False], [True, True, True, True, True, True, True, True]], coeffs=[ 1. + 0.j, 0. + 1.j, 0. - 1.j, 1. + 0.j, 0. + 1.j, -1. + 0.j, 1. + 0.j, 0. + 1.j, 0. - 1.j, 1. + 0.j, -1. + 0.j, 0. - 1.j, 1. + 0.j, 0. + 1.j, 0. - 1.j, 1. + 0.j ]), coeff=1.0) }, { 'E_0': [], 'Edag_0': [], 'E_1': [], 'Edag_1': [], 'E_2': [], 'Edag_2': [] }, { 'E_0': ((0, ), (1, )), 'Edag_0': ((1, ), (0, )), 'E_1': ((2, ), (3, )), 'Edag_1': ((3, ), (2, )), 'E_2': ((0, 2), (1, 3)), 'Edag_2': ((1, 3), (0, 2)) }) hopping_operators = _build_qeom_hopping_ops(self.q_molecule, self.qubit_converter) self.assertEqual(hopping_operators, expected_hopping_operators)
class TestGroundStateEigensolver(QiskitNatureTestCase): """Test GroundStateEigensolver""" def setUp(self): super().setUp() warnings.filterwarnings("ignore", category=DeprecationWarning, module=".*drivers.*") self.driver = HDF5Driver( self.get_resource_path("test_driver_hdf5.hdf5", "drivers/second_quantization/hdf5d")) self.seed = 56 algorithm_globals.random_seed = self.seed self.reference_energy = -1.1373060356951838 self.qubit_converter = QubitConverter(JordanWignerMapper()) self.electronic_structure_problem = ElectronicStructureProblem( self.driver) self.num_spin_orbitals = 4 self.num_particles = (1, 1) def test_npme(self): """Test NumPyMinimumEigensolver""" solver = NumPyMinimumEigensolverFactory() calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6) def test_npme_with_default_filter(self): """Test NumPyMinimumEigensolver with default filter""" solver = NumPyMinimumEigensolverFactory( use_default_filter_criterion=True) calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6) def test_vqe_uccsd(self): """Test VQE UCCSD case""" solver = VQEUCCFactory( quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator")), ansatz=UCC(excitations="d"), ) calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6) def test_vqe_uccsd_with_callback(self): """Test VQE UCCSD with callback.""" def callback(nfev, parameters, energy, stddev): # pylint: disable=unused-argument print(f"iterations {nfev}: energy: {energy}") solver = VQEUCCFactory( quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator")), callback=callback, ) calc = GroundStateEigensolver(self.qubit_converter, solver) with contextlib.redirect_stdout(io.StringIO()) as out: res = calc.solve(self.electronic_structure_problem) self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6) for idx, line in enumerate(out.getvalue().split("\n")): if line.strip(): self.assertTrue( line.startswith(f"iterations {idx+1}: energy: ")) def test_vqe_ucc_custom(self): """Test custom ansatz in Factory use case""" solver = VQEUCCFactory(quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator"))) calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6) def test_aux_ops_reusability(self): """Test that the auxiliary operators can be reused""" # Regression test against #1475 solver = NumPyMinimumEigensolverFactory() calc = GroundStateEigensolver(self.qubit_converter, solver) modes = 4 h_1 = np.eye(modes, dtype=complex) h_2 = np.zeros((modes, modes, modes, modes)) aux_ops = list( ElectronicEnergy([ OneBodyElectronicIntegrals(ElectronicBasis.MO, (h_1, None)), TwoBodyElectronicIntegrals(ElectronicBasis.MO, (h_2, None, None, None)), ], ).second_q_ops().values()) aux_ops_copy = copy.deepcopy(aux_ops) _ = calc.solve(self.electronic_structure_problem) assert all( frozenset(a.to_list()) == frozenset(b.to_list()) for a, b in zip(aux_ops, aux_ops_copy)) def test_list_based_aux_ops(self): """Test the list based aux ops variant""" msg_ref = ( "List-based `aux_operators` are deprecated as of version 0.3.0 and support " "for them will be removed no sooner than 3 months after the release. Instead, " "use dict-based `aux_operators`. You can switch to the dict-based interface " "immediately, by setting `qiskit_nature.settings.dict_aux_operators` to `True`." ) with warnings.catch_warnings(record=True) as c_m: warnings.simplefilter("always") settings.dict_aux_operators = False try: solver = NumPyMinimumEigensolverFactory() calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6) self.assertTrue( np.all( isinstance(aux_op, dict) for aux_op in res.aux_operator_eigenvalues)) aux_op_eigenvalue = res.aux_operator_eigenvalues[0] self.assertAlmostEqual(aux_op_eigenvalue[0][0], 2.0, places=6) self.assertAlmostEqual(aux_op_eigenvalue[1][1], 0.0, places=6) self.assertAlmostEqual(aux_op_eigenvalue[2][0], 0.0, places=6) self.assertAlmostEqual(aux_op_eigenvalue[2][1], 0.0, places=6) self.assertAlmostEqual(aux_op_eigenvalue[3][0], 0.0, places=6) self.assertAlmostEqual(aux_op_eigenvalue[3][1], 0.0, places=6) self.assertAlmostEqual(aux_op_eigenvalue[4][0], 0.0, places=6) self.assertAlmostEqual(aux_op_eigenvalue[4][1], 0.0, places=6) self.assertAlmostEqual(aux_op_eigenvalue[5][0], -1.3889487, places=6) self.assertAlmostEqual(aux_op_eigenvalue[5][1], 0.0, places=6) finally: settings.dict_aux_operators = True msg = str(c_m[0].message) self.assertEqual(msg, msg_ref) def _setup_evaluation_operators(self): # first we run a ground state calculation solver = VQEUCCFactory(quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator"))) calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) # now we decide that we want to evaluate another operator # for testing simplicity, we just use some pre-constructed auxiliary operators second_q_ops = self.electronic_structure_problem.second_q_ops() # Remove main op to leave just aux ops second_q_ops.pop(self.electronic_structure_problem.main_property_name) aux_ops_dict = self.qubit_converter.convert_match(second_q_ops) return calc, res, aux_ops_dict def test_eval_op_single(self): """Test evaluating a single additional operator""" calc, res, aux_ops = self._setup_evaluation_operators() # we filter the list because in this test we test a single operator evaluation add_aux_op = aux_ops["ParticleNumber"][0] # now we have the ground state calculation evaluate it add_aux_op_res = calc.evaluate_operators(res.raw_result.eigenstate, add_aux_op) self.assertIsInstance(add_aux_op_res[0], complex) self.assertAlmostEqual(add_aux_op_res[0].real, 2, places=6) def test_eval_op_single_none(self): """Test evaluating a single `None` operator""" calc, res, _ = self._setup_evaluation_operators() # we filter the list because in this test we test a single operator evaluation add_aux_op = None # now we have the ground state calculation evaluate it add_aux_op_res = calc.evaluate_operators(res.raw_result.eigenstate, add_aux_op) self.assertIsNone(add_aux_op_res) def test_eval_op_list(self): """Test evaluating a list of additional operators""" calc, res, aux_ops = self._setup_evaluation_operators() # we filter the list because of simplicity expected_results = { "number of particles": 2, "s^2": 0, "magnetization": 0 } add_aux_op = [ aux_ops["ParticleNumber"], aux_ops["AngularMomentum"], aux_ops["Magnetization"], ] # now we have the ground state calculation evaluate them add_aux_op_res = calc.evaluate_operators(res.raw_result.eigenstate, add_aux_op) self.assertIsInstance(add_aux_op_res, list) # in this list we require that the order of the results remains unchanged for idx, expected in enumerate(expected_results.values()): self.assertAlmostEqual(add_aux_op_res[idx][0].real, expected, places=6) def test_eval_op_list_none(self): """Test evaluating a list of additional operators incl. `None`""" calc, res, aux_ops = self._setup_evaluation_operators() # we filter the list because of simplicity expected_results = { "number of particles": 2, "s^2": 0, "magnetization": 0 } add_aux_op = [ aux_ops["ParticleNumber"], aux_ops["AngularMomentum"], aux_ops["Magnetization"], ] + [None] # now we have the ground state calculation evaluate them add_aux_op_res = calc.evaluate_operators(res.raw_result.eigenstate, add_aux_op) self.assertIsInstance(add_aux_op_res, list) # in this list we require that the order of the results remains unchanged for idx, expected in enumerate(expected_results.values()): self.assertAlmostEqual(add_aux_op_res[idx][0].real, expected, places=6) self.assertIsNone(add_aux_op_res[-1]) def test_eval_op_dict(self): """Test evaluating a dict of additional operators""" calc, res, aux_ops = self._setup_evaluation_operators() # we filter the list because of simplicity expected_results = { "number of particles": 2, "s^2": 0, "magnetization": 0 } add_aux_op = [ aux_ops["ParticleNumber"], aux_ops["AngularMomentum"], aux_ops["Magnetization"], ] # now we convert it into a dictionary add_aux_op = dict(zip(expected_results.keys(), add_aux_op)) # now we have the ground state calculation evaluate them add_aux_op_res = calc.evaluate_operators(res.raw_result.eigenstate, add_aux_op) self.assertIsInstance(add_aux_op_res, dict) for name, expected in expected_results.items(): self.assertAlmostEqual(add_aux_op_res[name][0].real, expected, places=6) def test_eval_op_dict_none(self): """Test evaluating a dict of additional operators incl. `None`""" calc, res, aux_ops = self._setup_evaluation_operators() # we filter the list because of simplicity expected_results = { "number of particles": 2, "s^2": 0, "magnetization": 0 } add_aux_op = [ aux_ops["ParticleNumber"], aux_ops["AngularMomentum"], aux_ops["Magnetization"], ] # now we convert it into a dictionary add_aux_op = dict(zip(expected_results.keys(), add_aux_op)) add_aux_op["None"] = None # now we have the ground state calculation evaluate them add_aux_op_res = calc.evaluate_operators(res.raw_result.eigenstate, add_aux_op) self.assertIsInstance(add_aux_op_res, dict) for name, expected in expected_results.items(): self.assertAlmostEqual(add_aux_op_res[name][0].real, expected, places=6) self.assertIsNone(add_aux_op_res["None"]) @slow_test def test_eval_op_qasm(self): """Regression tests against https://github.com/Qiskit/qiskit-nature/issues/53.""" solver = VQEUCCFactory( optimizer=SLSQP(maxiter=100), expectation=PauliExpectation(), quantum_instance=QuantumInstance( backend=BasicAer.get_backend("qasm_simulator"), seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed, ), ) calc = GroundStateEigensolver(self.qubit_converter, solver) res_qasm = calc.solve(self.electronic_structure_problem) hamiltonian = self.electronic_structure_problem.second_q_ops()[ self.electronic_structure_problem.main_property_name] qubit_op = self.qubit_converter.map(hamiltonian) ansatz = solver.get_solver(self.electronic_structure_problem, self.qubit_converter).ansatz circuit = ansatz.assign_parameters(res_qasm.raw_result.optimal_point) mean = calc.evaluate_operators(circuit, qubit_op) self.assertAlmostEqual(res_qasm.eigenenergies[0], mean[0].real) @unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required to run this test") def test_eval_op_qasm_aer(self): """Regression tests against https://github.com/Qiskit/qiskit-nature/issues/53.""" backend = qiskit.providers.aer.Aer.get_backend("aer_simulator") solver = VQEUCCFactory( optimizer=SLSQP(maxiter=100), expectation=AerPauliExpectation(), include_custom=True, quantum_instance=QuantumInstance( backend=backend, seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed, ), ) calc = GroundStateEigensolver(self.qubit_converter, solver) res_qasm = calc.solve(self.electronic_structure_problem) hamiltonian = self.electronic_structure_problem.second_q_ops()[ self.electronic_structure_problem.main_property_name] qubit_op = self.qubit_converter.map(hamiltonian) ansatz = solver.get_solver(self.electronic_structure_problem, self.qubit_converter).ansatz circuit = ansatz.assign_parameters(res_qasm.raw_result.optimal_point) mean = calc.evaluate_operators(circuit, qubit_op) self.assertAlmostEqual(res_qasm.eigenenergies[0], mean[0].real) def _prepare_uccsd_hf(self, qubit_converter): initial_state = HartreeFock(self.num_spin_orbitals, self.num_particles, qubit_converter) ansatz = UCCSD( qubit_converter, self.num_particles, self.num_spin_orbitals, initial_state=initial_state, ) return ansatz def test_uccsd_hf(self): """uccsd hf test""" ansatz = self._prepare_uccsd_hf(self.qubit_converter) optimizer = SLSQP(maxiter=100) backend = BasicAer.get_backend("statevector_simulator") solver = VQE( ansatz=ansatz, optimizer=optimizer, quantum_instance=QuantumInstance(backend=backend), ) gsc = GroundStateEigensolver(self.qubit_converter, solver) result = gsc.solve(self.electronic_structure_problem) self.assertAlmostEqual(result.total_energies[0], self.reference_energy, places=6) @slow_test def test_uccsd_hf_qasm(self): """uccsd hf test with qasm simulator.""" qubit_converter = QubitConverter(ParityMapper()) ansatz = self._prepare_uccsd_hf(qubit_converter) backend = BasicAer.get_backend("qasm_simulator") optimizer = SPSA(maxiter=200, last_avg=5) solver = VQE( ansatz=ansatz, optimizer=optimizer, expectation=PauliExpectation(), quantum_instance=QuantumInstance( backend=backend, seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed, ), ) gsc = GroundStateEigensolver(qubit_converter, solver) result = gsc.solve(self.electronic_structure_problem) self.assertAlmostEqual(result.total_energies[0], -1.138, places=2) @slow_test @unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required to run this test") def test_uccsd_hf_aer_statevector(self): """uccsd hf test with Aer statevector""" backend = qiskit.providers.aer.Aer.get_backend( "aer_simulator_statevector") ansatz = self._prepare_uccsd_hf(self.qubit_converter) optimizer = SLSQP(maxiter=100) solver = VQE( ansatz=ansatz, optimizer=optimizer, quantum_instance=QuantumInstance(backend=backend), ) gsc = GroundStateEigensolver(self.qubit_converter, solver) result = gsc.solve(self.electronic_structure_problem) self.assertAlmostEqual(result.total_energies[0], self.reference_energy, places=6) @slow_test @unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required to run this test") def test_uccsd_hf_aer_qasm(self): """uccsd hf test with Aer qasm simulator.""" backend = qiskit.providers.aer.Aer.get_backend("aer_simulator") ansatz = self._prepare_uccsd_hf(self.qubit_converter) optimizer = SPSA(maxiter=200, last_avg=5) solver = VQE( ansatz=ansatz, optimizer=optimizer, expectation=PauliExpectation(group_paulis=False), quantum_instance=QuantumInstance( backend=backend, seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed, ), ) gsc = GroundStateEigensolver(self.qubit_converter, solver) result = gsc.solve(self.electronic_structure_problem) self.assertAlmostEqual(result.total_energies[0], -1.131, places=2) @slow_test @unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required to run this test") def test_uccsd_hf_aer_qasm_snapshot(self): """uccsd hf test with Aer qasm simulator snapshot.""" backend = qiskit.providers.aer.Aer.get_backend("aer_simulator") ansatz = self._prepare_uccsd_hf(self.qubit_converter) optimizer = SPSA(maxiter=200, last_avg=5) solver = VQE( ansatz=ansatz, optimizer=optimizer, expectation=AerPauliExpectation(), quantum_instance=QuantumInstance(backend=backend), ) gsc = GroundStateEigensolver(self.qubit_converter, solver) result = gsc.solve(self.electronic_structure_problem) self.assertAlmostEqual(result.total_energies[0], self.reference_energy, places=3) def test_freeze_core_z2_symmetry_compatibility(self): """Regression test against #192. An issue arose when the FreezeCoreTransformer was combined with the automatic Z2Symmetry reduction. This regression test ensures that this behavior remains fixed. """ driver = HDF5Driver(hdf5_input=self.get_resource_path( "LiH_sto3g.hdf5", "transformers/second_quantization/electronic")) problem = ElectronicStructureProblem(driver, [FreezeCoreTransformer()]) qubit_converter = QubitConverter( ParityMapper(), two_qubit_reduction=True, z2symmetry_reduction="auto", ) solver = NumPyMinimumEigensolverFactory() gsc = GroundStateEigensolver(qubit_converter, solver) result = gsc.solve(problem) self.assertAlmostEqual(result.total_energies[0], -7.882, places=2) def test_total_dipole(self): """Regression test against #198. An issue with calculating the dipole moment that had division None/float. """ solver = NumPyMinimumEigensolverFactory() calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) self.assertAlmostEqual(res.total_dipole_moment_in_debye[0], 0.0, places=1) def test_print_result(self): """Regression test against #198 and general issues with printing results.""" solver = NumPyMinimumEigensolverFactory() calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) with contextlib.redirect_stdout(io.StringIO()) as out: print(res) # do NOT change the below! Lines have been truncated as to not force exact numerical matches expected = """\ === GROUND STATE ENERGY === * Electronic ground state energy (Hartree): -1.857 - computed part: -1.857 ~ Nuclear repulsion energy (Hartree): 0.719 > Total ground state energy (Hartree): -1.137 === MEASURED OBSERVABLES === 0: # Particles: 2.000 S: 0.000 S^2: 0.000 M: 0.000 === DIPOLE MOMENTS === ~ Nuclear dipole moment (a.u.): [0.0 0.0 1.38 0: * Electronic dipole moment (a.u.): [0.0 0.0 -1.38 - computed part: [0.0 0.0 -1.38 > Dipole moment (a.u.): [0.0 0.0 0.0] Total: 0. (debye): [0.0 0.0 0.0] Total: 0. """ for truth, expected in zip(out.getvalue().split("\n"), expected.split("\n")): assert truth.strip().startswith(expected.strip()) def test_default_initial_point(self): """Test when using the default initial point.""" solver = VQEUCCFactory(quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator"))) calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) np.testing.assert_array_equal(solver.initial_point.to_numpy_array(), [0.0, 0.0, 0.0]) self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6) def test_vqe_ucc_factory_with_user_initial_point(self): """Test VQEUCCFactory when using it with a user defined initial point.""" initial_point = np.asarray( [1.28074029e-19, 5.92226076e-08, 1.11762559e-01]) solver = VQEUCCFactory( quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator")), initial_point=initial_point, optimizer=SLSQP(maxiter=1), ) calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) np.testing.assert_array_almost_equal(res.raw_result.optimal_point, initial_point) def test_vqe_ucc_factory_with_mp2(self): """Test when using MP2InitialPoint to generate the initial point.""" informed_start = MP2InitialPoint() solver = VQEUCCFactory( quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator")), initial_point=informed_start, ) calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) np.testing.assert_array_almost_equal( solver.initial_point.to_numpy_array(), [0.0, 0.0, -0.07197145]) self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6)
class TestUCCSDHartreeFock(QiskitNatureTestCase): """Test for these extensions.""" @unittest.skipIf(not _optionals.HAS_PYSCF, "pyscf not available.") def setUp(self): super().setUp() self.driver = PySCFDriver(atom="H 0 0 0.735; H 0 0 0", basis="631g") self.qubit_converter = QubitConverter(ParityMapper(), two_qubit_reduction=True) self.electronic_structure_problem = ElectronicStructureProblem( self.driver, [FreezeCoreTransformer()]) self.num_spin_orbitals = 8 self.num_particles = (1, 1) # because we create the initial state and ansatzes early, we need to ensure the qubit # converter already ran such that convert_match works as expected _ = self.qubit_converter.convert( self.electronic_structure_problem.second_q_ops()[0], self.num_particles) 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]], ] @slow_test def test_uccsd_hf_qpUCCD(self): """paired uccd test""" self.skipTest( "Temporarily skip test until the changes done by " "https://github.com/Qiskit/qiskit-terra/pull/7551 are handled properly." ) optimizer = SLSQP(maxiter=100) initial_state = HartreeFock(self.num_spin_orbitals, self.num_particles, self.qubit_converter) ansatz = PUCCD( self.qubit_converter, self.num_particles, self.num_spin_orbitals, initial_state=initial_state, ) solver = VQE( ansatz=ansatz, optimizer=optimizer, quantum_instance=QuantumInstance( backend=BasicAer.get_backend("statevector_simulator")), ) gsc = GroundStateEigensolver(self.qubit_converter, solver) result = gsc.solve(self.electronic_structure_problem) self.assertAlmostEqual(result.total_energies[0], self.reference_energy_pUCCD, places=6) @slow_test def test_uccsd_hf_qUCCD0(self): """singlet uccd test""" self.skipTest( "Temporarily skip test until the changes done by " "https://github.com/Qiskit/qiskit-terra/pull/7551 are handled properly." ) optimizer = SLSQP(maxiter=100) initial_state = HartreeFock(self.num_spin_orbitals, self.num_particles, self.qubit_converter) ansatz = SUCCD( self.qubit_converter, self.num_particles, self.num_spin_orbitals, initial_state=initial_state, ) solver = VQE( ansatz=ansatz, optimizer=optimizer, quantum_instance=QuantumInstance( backend=BasicAer.get_backend("statevector_simulator")), ) gsc = GroundStateEigensolver(self.qubit_converter, solver) result = gsc.solve(self.electronic_structure_problem) self.assertAlmostEqual(result.total_energies[0], self.reference_energy_UCCD0, places=6) @unittest.skip( "Skip until https://github.com/Qiskit/qiskit-nature/issues/91 is closed." ) def test_uccsd_hf_qUCCD0full(self): """singlet full uccd test""" optimizer = SLSQP(maxiter=100) initial_state = HartreeFock(self.num_spin_orbitals, self.num_particles, self.qubit_converter) # TODO: add `full` option ansatz = SUCCD( self.qubit_converter, self.num_particles, self.num_spin_orbitals, initial_state=initial_state, ) solver = VQE( ansatz=ansatz, optimizer=optimizer, quantum_instance=QuantumInstance( backend=BasicAer.get_backend("statevector_simulator")), ) gsc = GroundStateEigensolver(self.qubit_converter, solver) result = gsc.solve(self.electronic_structure_problem) self.assertAlmostEqual(result.total_energies[0], self.reference_energy_UCCD0full, places=6)
def test_h2_bopes_sampler_auxiliaries(self): """Test BOPES Sampler on H2""" # Molecule dof = partial(Molecule.absolute_distance, atom_pair=(1, 0)) m = Molecule( geometry=[["H", [0.0, 0.0, 1.0]], ["H", [0.0, 0.45, 1.0]]], degrees_of_freedom=[dof], ) driver = ElectronicStructureMoleculeDriver( m, driver_type=ElectronicStructureDriverType.PYSCF) problem = ElectronicStructureProblem(driver) qubit_converter = QubitConverter(JordanWignerMapper(), z2symmetry_reduction=None) quantum_instance = QuantumInstance( backend=qiskit.providers.aer.Aer.get_backend( "aer_simulator_statevector"), seed_simulator=self.seed, seed_transpiler=self.seed, ) solver = VQE(quantum_instance=quantum_instance) me_gsc = GroundStateEigensolver(qubit_converter, solver) # Sets up the auxiliary operators def build_hamiltonian( current_problem: BaseProblem) -> SecondQuantizedOp: """Returns the SecondQuantizedOp H(R) where H is the electronic hamiltonian and R is the current nuclear coordinates. This gives the electronic energies.""" hamiltonian_name = current_problem.main_property_name hamiltonian_op = current_problem.second_q_ops().get( hamiltonian_name, None) return hamiltonian_op aux = { "PN": problem.second_q_ops()["ParticleNumber"], # SecondQuantizedOp "EN": build_hamiltonian, # Callable "IN": PauliOp(Pauli("IIII"), 1.0), # PauliOp } # Note that the first item is defined once for R=0.45. # The second item is a function of the problem giving the electronic energy. # At each step, a perturbation is applied to the molecule degrees of freedom which updates # the aux_operators. # The third item is the identity written as a PauliOp, yielding the norm of the eigenstates. # Sets up the BOPESSampler sampler = BOPESSampler(me_gsc) # absolute internuclear distance in Angstrom points = [0.7, 1.0, 1.3] results = sampler.sample(problem, points, aux_operators=aux) points_run = results.points particle_numbers = [] total_energies = [] norm_eigenstates = [] for results_point in list(results.raw_results.values()): aux_op_dict = results_point.raw_result.aux_operator_eigenvalues particle_numbers.append(aux_op_dict["PN"][0]) total_energies.append(aux_op_dict["EN"][0] + results_point.nuclear_repulsion_energy) norm_eigenstates.append(aux_op_dict["IN"][0]) points_run_reference = [0.7, 1.0, 1.3] particle_numbers_reference = [2, 2, 2] total_energies_reference = [-1.136, -1.101, -1.035] norm_eigenstates_reference = [1, 1, 1] np.testing.assert_array_almost_equal(points_run, points_run_reference) np.testing.assert_array_almost_equal(particle_numbers, particle_numbers_reference, decimal=2) np.testing.assert_array_almost_equal( total_energies, total_energies_reference, decimal=2, ) np.testing.assert_array_almost_equal( norm_eigenstates, norm_eigenstates_reference, decimal=2, )
class TestHoppingOpsBuilder(QiskitNatureTestCase): """Tests Hopping Operators builder.""" @unittest.skipIf(not _optionals.HAS_PYSCF, "pyscf not available.") def setUp(self): super().setUp() algorithm_globals.random_seed = 8 self.driver = PySCFDriver( atom="H .0 .0 .0; H .0 .0 0.75", unit=UnitsType.ANGSTROM, charge=0, spin=0, basis="sto3g", ) self.qubit_converter = QubitConverter(JordanWignerMapper()) self.electronic_structure_problem = ElectronicStructureProblem(self.driver) self.electronic_structure_problem.second_q_ops() self.particle_number = ( self.electronic_structure_problem.grouped_property_transformed.get_property( "ParticleNumber" ) ) def test_build_hopping_operators(self): """Tests that the correct hopping operator is built from QMolecule.""" # TODO extract it somewhere expected_hopping_operators = ( { "E_0": PauliSumOp.from_list( [("IIXX", 1), ("IIYX", 1j), ("IIXY", -1j), ("IIYY", 1)] ), "Edag_0": PauliSumOp.from_list( [("IIXX", -1), ("IIYX", 1j), ("IIXY", -1j), ("IIYY", -1)] ), "E_1": PauliSumOp.from_list( [("XXII", 1), ("YXII", 1j), ("XYII", -1j), ("YYII", 1)] ), "Edag_1": PauliSumOp.from_list( [("XXII", -1), ("YXII", 1j), ("XYII", -1j), ("YYII", -1)] ), "E_2": PauliSumOp.from_list( [ ("XXXX", 1), ("YXXX", 1j), ("XYXX", -1j), ("YYXX", 1), ("XXYX", 1j), ("YXYX", -1), ("XYYX", 1), ("YYYX", 1j), ("XXXY", -1j), ("YXXY", 1), ("XYXY", -1), ("YYXY", -1j), ("XXYY", 1), ("YXYY", 1j), ("XYYY", -1j), ("YYYY", 1), ] ), "Edag_2": PauliSumOp.from_list( [ ("XXXX", 1), ("YXXX", -1j), ("XYXX", 1j), ("YYXX", 1), ("XXYX", -1j), ("YXYX", -1), ("XYYX", 1), ("YYYX", -1j), ("XXXY", 1j), ("YXXY", 1), ("XYXY", -1), ("YYXY", 1j), ("XXYY", 1), ("YXYY", -1j), ("XYYY", 1j), ("YYYY", 1), ] ), }, {"E_0": [], "Edag_0": [], "E_1": [], "Edag_1": [], "E_2": [], "Edag_2": []}, { "E_0": ((0,), (1,)), "Edag_0": ((1,), (0,)), "E_1": ((2,), (3,)), "Edag_1": ((3,), (2,)), "E_2": ((0, 2), (1, 3)), "Edag_2": ((1, 3), (0, 2)), }, ) hopping_operators = _build_qeom_hopping_ops(self.particle_number, self.qubit_converter) self.assertEqual(hopping_operators, expected_hopping_operators)
class TestGroundStateEigensolver(QiskitNatureTestCase): """ Test GroundStateEigensolver """ def setUp(self): super().setUp() self.driver = HDF5Driver( self.get_resource_path('test_driver_hdf5.hdf5', 'drivers/hdf5d')) self.seed = 700 algorithm_globals.random_seed = self.seed self.reference_energy = -1.1373060356951838 self.qubit_converter = QubitConverter(JordanWignerMapper()) self.electronic_structure_problem = ElectronicStructureProblem( self.driver) self.num_spin_orbitals = 4 self.num_particles = (1, 1) def test_npme(self): """ Test NumPyMinimumEigensolver """ solver = NumPyMinimumEigensolverFactory() calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6) def test_npme_with_default_filter(self): """ Test NumPyMinimumEigensolver with default filter """ solver = NumPyMinimumEigensolverFactory( use_default_filter_criterion=True) calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6) def test_vqe_uccsd(self): """ Test VQE UCCSD case """ solver = VQEUCCFactory( quantum_instance=QuantumInstance( BasicAer.get_backend('statevector_simulator')), ansatz=UCC(excitations='d'), ) calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6) def test_vqe_ucc_custom(self): """ Test custom ansatz in Factory use case """ solver = VQEUCCFactory( QuantumInstance(BasicAer.get_backend('statevector_simulator'))) calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6) def test_aux_ops_reusability(self): """ Test that the auxiliary operators can be reused """ # Regression test against #1475 solver = NumPyMinimumEigensolverFactory() calc = GroundStateEigensolver(self.qubit_converter, solver) modes = 4 h_1 = np.eye(modes, dtype=complex) h_2 = np.zeros((modes, modes, modes, modes)) aux_ops = [build_ferm_op_from_ints(h_1, h_2)] aux_ops_copy = copy.deepcopy(aux_ops) _ = calc.solve(self.electronic_structure_problem) assert all( frozenset(a.to_list()) == frozenset(b.to_list()) for a, b in zip(aux_ops, aux_ops_copy)) def _setup_evaluation_operators(self): # first we run a ground state calculation solver = VQEUCCFactory( QuantumInstance(BasicAer.get_backend('statevector_simulator'))) calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) # now we decide that we want to evaluate another operator # for testing simplicity, we just use some pre-constructed auxiliary operators _, *aux_ops = self.qubit_converter.convert_match( self.electronic_structure_problem.second_q_ops()) return calc, res, aux_ops def test_eval_op_single(self): """ Test evaluating a single additional operator """ calc, res, aux_ops = self._setup_evaluation_operators() # we filter the list because in this test we test a single operator evaluation add_aux_op = aux_ops[0][0] # now we have the ground state calculation evaluate it add_aux_op_res = calc.evaluate_operators(res.raw_result.eigenstate, add_aux_op) self.assertIsInstance(add_aux_op_res[0], complex) self.assertAlmostEqual(add_aux_op_res[0].real, 2, places=6) def test_eval_op_single_none(self): """ Test evaluating a single `None` operator """ calc, res, _ = self._setup_evaluation_operators() # we filter the list because in this test we test a single operator evaluation add_aux_op = None # now we have the ground state calculation evaluate it add_aux_op_res = calc.evaluate_operators(res.raw_result.eigenstate, add_aux_op) self.assertIsNone(add_aux_op_res) def test_eval_op_list(self): """ Test evaluating a list of additional operators """ calc, res, aux_ops = self._setup_evaluation_operators() # we filter the list because of simplicity expected_results = { 'number of particles': 2, 's^2': 0, 'magnetization': 0 } add_aux_op = aux_ops[0:3] # now we have the ground state calculation evaluate them add_aux_op_res = calc.evaluate_operators(res.raw_result.eigenstate, add_aux_op) self.assertIsInstance(add_aux_op_res, list) # in this list we require that the order of the results remains unchanged for idx, expected in enumerate(expected_results.values()): self.assertAlmostEqual(add_aux_op_res[idx][0].real, expected, places=6) def test_eval_op_list_none(self): """ Test evaluating a list of additional operators incl. `None` """ calc, res, aux_ops = self._setup_evaluation_operators() # we filter the list because of simplicity expected_results = { 'number of particles': 2, 's^2': 0, 'magnetization': 0 } add_aux_op = aux_ops[0:3] + [None] # now we have the ground state calculation evaluate them add_aux_op_res = calc.evaluate_operators(res.raw_result.eigenstate, add_aux_op) self.assertIsInstance(add_aux_op_res, list) # in this list we require that the order of the results remains unchanged for idx, expected in enumerate(expected_results.values()): self.assertAlmostEqual(add_aux_op_res[idx][0].real, expected, places=6) self.assertIsNone(add_aux_op_res[-1]) def test_eval_op_dict(self): """ Test evaluating a dict of additional operators """ calc, res, aux_ops = self._setup_evaluation_operators() # we filter the list because of simplicity expected_results = { 'number of particles': 2, 's^2': 0, 'magnetization': 0 } add_aux_op = aux_ops[0:3] # now we convert it into a dictionary add_aux_op = dict(zip(expected_results.keys(), add_aux_op)) # now we have the ground state calculation evaluate them add_aux_op_res = calc.evaluate_operators(res.raw_result.eigenstate, add_aux_op) self.assertIsInstance(add_aux_op_res, dict) for name, expected in expected_results.items(): self.assertAlmostEqual(add_aux_op_res[name][0].real, expected, places=6) def test_eval_op_dict_none(self): """ Test evaluating a dict of additional operators incl. `None` """ calc, res, aux_ops = self._setup_evaluation_operators() # we filter the list because of simplicity expected_results = { 'number of particles': 2, 's^2': 0, 'magnetization': 0 } add_aux_op = aux_ops[0:3] # now we convert it into a dictionary add_aux_op = dict(zip(expected_results.keys(), add_aux_op)) add_aux_op['None'] = None # now we have the ground state calculation evaluate them add_aux_op_res = calc.evaluate_operators(res.raw_result.eigenstate, add_aux_op) self.assertIsInstance(add_aux_op_res, dict) for name, expected in expected_results.items(): self.assertAlmostEqual(add_aux_op_res[name][0].real, expected, places=6) self.assertIsNone(add_aux_op_res['None']) @slow_test def test_eval_op_qasm(self): """Regression tests against https://github.com/Qiskit/qiskit-nature/issues/53.""" solver = VQEUCCFactory( optimizer=SLSQP(maxiter=100), expectation=PauliExpectation(), quantum_instance=QuantumInstance( backend=BasicAer.get_backend('qasm_simulator'), seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed)) calc = GroundStateEigensolver(self.qubit_converter, solver) res_qasm = calc.solve(self.electronic_structure_problem) hamiltonian = self.electronic_structure_problem.second_q_ops()[0] qubit_op = self.qubit_converter.map(hamiltonian) ansatz = solver.get_solver(self.electronic_structure_problem, self.qubit_converter).ansatz circuit = ansatz.assign_parameters(res_qasm.raw_result.optimal_point) mean = calc.evaluate_operators(circuit, qubit_op) self.assertAlmostEqual(res_qasm.eigenenergies[0], mean[0].real) def test_eval_op_qasm_aer(self): """Regression tests against https://github.com/Qiskit/qiskit-nature/issues/53.""" try: # pylint: disable=import-outside-toplevel # pylint: disable=unused-import from qiskit import Aer backend = Aer.get_backend('qasm_simulator') except ImportError as ex: # pylint: disable=broad-except self.skipTest( "Aer doesn't appear to be installed. Error: '{}'".format( str(ex))) return solver = VQEUCCFactory( optimizer=SLSQP(maxiter=100), expectation=AerPauliExpectation(), include_custom=True, quantum_instance=QuantumInstance( backend=backend, seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed)) calc = GroundStateEigensolver(self.qubit_converter, solver) res_qasm = calc.solve(self.electronic_structure_problem) hamiltonian = self.electronic_structure_problem.second_q_ops()[0] qubit_op = self.qubit_converter.map(hamiltonian) ansatz = solver.get_solver(self.electronic_structure_problem, self.qubit_converter).ansatz circuit = ansatz.assign_parameters(res_qasm.raw_result.optimal_point) mean = calc.evaluate_operators(circuit, qubit_op) self.assertAlmostEqual(res_qasm.eigenenergies[0], mean[0].real) def _prepare_uccsd_hf(self, qubit_converter): initial_state = HartreeFock(self.num_spin_orbitals, self.num_particles, qubit_converter) ansatz = UCCSD(qubit_converter, self.num_particles, self.num_spin_orbitals, initial_state=initial_state) return ansatz def test_uccsd_hf(self): """ uccsd hf test """ ansatz = self._prepare_uccsd_hf(self.qubit_converter) optimizer = SLSQP(maxiter=100) backend = BasicAer.get_backend('statevector_simulator') solver = VQE(ansatz=ansatz, optimizer=optimizer, quantum_instance=QuantumInstance(backend=backend)) gsc = GroundStateEigensolver(self.qubit_converter, solver) result = gsc.solve(self.electronic_structure_problem) self.assertAlmostEqual(result.total_energies[0], self.reference_energy, places=6) @slow_test def test_uccsd_hf_qasm(self): """ uccsd hf test with qasm_simulator. """ qubit_converter = QubitConverter(ParityMapper()) ansatz = self._prepare_uccsd_hf(qubit_converter) backend = BasicAer.get_backend('qasm_simulator') optimizer = SPSA(maxiter=200, last_avg=5) solver = VQE(ansatz=ansatz, optimizer=optimizer, expectation=PauliExpectation(), quantum_instance=QuantumInstance( backend=backend, seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed)) gsc = GroundStateEigensolver(qubit_converter, solver) result = gsc.solve(self.electronic_structure_problem) self.assertAlmostEqual(result.total_energies[0], -1.138, places=2) def test_uccsd_hf_aer_statevector(self): """ uccsd hf test with Aer statevector """ try: # pylint: disable=import-outside-toplevel from qiskit import Aer backend = Aer.get_backend('statevector_simulator') except ImportError as ex: # pylint: disable=broad-except self.skipTest( "Aer doesn't appear to be installed. Error: '{}'".format( str(ex))) return ansatz = self._prepare_uccsd_hf(self.qubit_converter) optimizer = SLSQP(maxiter=100) solver = VQE(ansatz=ansatz, optimizer=optimizer, quantum_instance=QuantumInstance(backend=backend)) gsc = GroundStateEigensolver(self.qubit_converter, solver) result = gsc.solve(self.electronic_structure_problem) self.assertAlmostEqual(result.total_energies[0], self.reference_energy, places=6) @slow_test def test_uccsd_hf_aer_qasm(self): """ uccsd hf test with Aer qasm_simulator. """ try: # pylint: disable=import-outside-toplevel from qiskit import Aer backend = Aer.get_backend('qasm_simulator') except ImportError as ex: # pylint: disable=broad-except self.skipTest( "Aer doesn't appear to be installed. Error: '{}'".format( str(ex))) return ansatz = self._prepare_uccsd_hf(self.qubit_converter) optimizer = SPSA(maxiter=200, last_avg=5) solver = VQE(ansatz=ansatz, optimizer=optimizer, expectation=PauliExpectation(), quantum_instance=QuantumInstance( backend=backend, seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed)) gsc = GroundStateEigensolver(self.qubit_converter, solver) result = gsc.solve(self.electronic_structure_problem) self.assertAlmostEqual(result.total_energies[0], -1.138, places=2) @slow_test def test_uccsd_hf_aer_qasm_snapshot(self): """ uccsd hf test with Aer qasm_simulator snapshot. """ try: # pylint: disable=import-outside-toplevel from qiskit import Aer backend = Aer.get_backend('qasm_simulator') except ImportError as ex: # pylint: disable=broad-except self.skipTest( "Aer doesn't appear to be installed. Error: '{}'".format( str(ex))) return ansatz = self._prepare_uccsd_hf(self.qubit_converter) optimizer = SPSA(maxiter=200, last_avg=5) solver = VQE(ansatz=ansatz, optimizer=optimizer, expectation=AerPauliExpectation(), quantum_instance=QuantumInstance(backend=backend)) gsc = GroundStateEigensolver(self.qubit_converter, solver) result = gsc.solve(self.electronic_structure_problem) self.assertAlmostEqual(result.total_energies[0], self.reference_energy, places=3)