def setUp(self): super().setUp() self.driver1 = HDF5Driver(hdf5_input=self.get_resource_path( 'test_oovqe_h4.hdf5', 'algorithms/ground_state_solvers')) self.driver2 = HDF5Driver(hdf5_input=self.get_resource_path( 'test_oovqe_lih.hdf5', 'algorithms/ground_state_solvers')) self.driver3 = HDF5Driver(hdf5_input=self.get_resource_path( 'test_oovqe_h4_uhf.hdf5', 'algorithms/ground_state_solvers')) self.energy1_rotation = -3.0104 self.energy1 = -2.77 # energy of the VQE with pUCCD ansatz and LBFGSB optimizer self.energy2 = -7.70 self.energy3 = -2.50 self.initial_point1 = [ 0.039374, -0.47225463, -0.61891996, 0.02598386, 0.79045546, -0.04134567, 0.04944946, -0.02971617, -0.00374005, 0.77542149 ] self.seed = 50 self.optimizer = COBYLA(maxiter=1) self.transformation1 = \ FermionicTransformation(qubit_mapping=FermionicQubitMappingType.JORDAN_WIGNER, two_qubit_reduction=False) self.transformation2 = \ FermionicTransformation(qubit_mapping=FermionicQubitMappingType.JORDAN_WIGNER, two_qubit_reduction=False, freeze_core=True) self.quantum_instance = QuantumInstance( BasicAer.get_backend('statevector_simulator'), shots=1, seed_simulator=self.seed, seed_transpiler=self.seed)
def test_freeze_core_with_remove_orbitals(self): """Test the `freeze_core` convenience argument in combination with `remove_orbitals`.""" driver = HDF5Driver(hdf5_input=self.get_resource_path('BeH_sto3g.hdf5', 'transformers')) q_molecule = driver.run() trafo = FreezeCoreTransformer(freeze_core=True, remove_orbitals=[4, 5]) q_molecule_reduced = trafo.transform(q_molecule) expected = HDF5Driver(hdf5_input=self.get_resource_path('BeH_sto3g_reduced.hdf5', 'transformers')).run() self.assertQMolecule(q_molecule_reduced, expected, dict_key='FreezeCoreTransformer')
def test_freeze_core(self): """Test the `freeze_core` convenience argument.""" driver = HDF5Driver(hdf5_input=self.get_resource_path('LiH_sto3g.hdf5', 'transformers')) q_molecule = driver.run() trafo = FreezeCoreTransformer(freeze_core=True) q_molecule_reduced = trafo.transform(q_molecule) expected = HDF5Driver(hdf5_input=self.get_resource_path('LiH_sto3g_reduced.hdf5', 'transformers')).run() self.assertQMolecule(q_molecule_reduced, expected, dict_key='FreezeCoreTransformer')
def setUp(self): super().setUp() driver = HDF5Driver(hdf5_input=self.get_resource_path( "test_driver_hdf5.hdf5", "drivers/second_quantization/hdf5d")) temp_qmolecule = driver.run() file, self.save_file = tempfile.mkstemp(suffix=".hdf5") os.close(file) temp_qmolecule.save(self.save_file) # Tests are run on self.qmolecule which is from new saved HDF5 file # so save is tested based on getting expected values as per original driver = HDF5Driver(hdf5_input=self.save_file) self.qmolecule = driver.run()
def test_unpaired_electron_active_space(self): """Test an active space with an unpaired electron.""" driver = HDF5Driver(hdf5_input=self.get_resource_path('BeH_sto3g.hdf5', 'transformers')) q_molecule = driver.run() trafo = ActiveSpaceTransformer(num_electrons=(2, 1), num_molecular_orbitals=3) q_molecule_reduced = trafo.transform(q_molecule) expected = HDF5Driver(hdf5_input=self.get_resource_path('BeH_sto3g_reduced.hdf5', 'transformers')).run() self.assertQMolecule(q_molecule_reduced, expected)
def setUp(self): super().setUp() driver = HDF5Driver(hdf5_input=self.get_resource_path( "test_driver_hdf5.hdf5", "drivers/hdf5d")) self.molecule = driver.run() self.num_particles = (self.molecule.num_alpha, self.molecule.num_beta) self.h2_op = fermionic_op_builder._build_fermionic_op(self.molecule)
def test_minimal_active_space(self): """Test a minimal active space manually.""" driver = HDF5Driver(hdf5_input=self.get_resource_path( "H2_631g.hdf5", "transformers/second_quantization/electronic")) q_molecule = driver.run() trafo = ActiveSpaceTransformer(num_electrons=2, num_molecular_orbitals=2) q_molecule_reduced = trafo.transform(q_molecule) expected = QMolecule() expected.mo_onee_ints = np.asarray([[-1.24943841, 0.0], [0.0, -0.547816138]]) expected.mo_eri_ints = np.asarray([ [ [[0.652098466, 0.0], [0.0, 0.433536565]], [[0.0, 0.0794483182], [0.0794483182, 0.0]], ], [ [[0.0, 0.0794483182], [0.0794483182, 0.0]], [[0.433536565, 0.0], [0.0, 0.385524695]], ], ]) expected.x_dip_mo_ints = np.zeros((2, 2)) expected.y_dip_mo_ints = np.zeros((2, 2)) expected.z_dip_mo_ints = np.asarray([[0.69447435, -1.01418298], [-1.01418298, 0.69447435]]) expected.energy_shift["ActiveSpaceTransformer"] = 0.0 expected.x_dip_energy_shift["ActiveSpaceTransformer"] = 0.0 expected.y_dip_energy_shift["ActiveSpaceTransformer"] = 0.0 expected.z_dip_energy_shift["ActiveSpaceTransformer"] = 0.0 self.assertQMolecule(q_molecule_reduced, expected)
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')) fermionic_transformation = \ FermionicTransformation(qubit_mapping=FermionicQubitMappingType.PARITY, two_qubit_reduction=False) qubit_op, _ = fermionic_transformation.transform(driver) optimizer = SLSQP(maxiter=100) initial_state = HartreeFock( fermionic_transformation.molecule_info['num_orbitals'], fermionic_transformation.molecule_info['num_particles'], qubit_mapping=fermionic_transformation._qubit_mapping, two_qubit_reduction=fermionic_transformation._two_qubit_reduction) wavefunction = ExcitationPreserving(qubit_op.num_qubits) wavefunction.compose(initial_state, front=True, inplace=True) solver = VQE(var_form=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(fermionic_transformation, solver) result = gsc.solve(driver) self.assertAlmostEqual(result.total_energies[0], self.reference_energy, places=4)
def test_freeze_core(self): """Test the `freeze_core` convenience argument.""" driver = HDF5Driver(hdf5_input=self.get_resource_path( "LiH_sto3g.hdf5", "transformers/second_quantization/electronic")) q_molecule = driver.run() trafo = FreezeCoreTransformer(freeze_core=True) q_molecule_reduced = trafo.transform(q_molecule) expected = HDF5Driver(hdf5_input=self.get_resource_path( "LiH_sto3g_reduced.hdf5", "transformers/second_quantization/electronic")).run() self.assertQMolecule(q_molecule_reduced, expected, dict_key="FreezeCoreTransformer")
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_minimal_active_space(self): """Test a minimal active space manually.""" driver = HDF5Driver( hdf5_input=self.get_resource_path('H2_631g.hdf5', 'transformers')) q_molecule = driver.run() trafo = ActiveSpaceTransformer(num_electrons=2, num_orbitals=2) q_molecule_reduced = trafo.transform(q_molecule) expected_mo_onee_ints = np.asarray([[-1.24943841, 0.0], [0.0, -0.547816138]]) expected_mo_eri_ints = np.asarray([[[[0.652098466, 0.0], [0.0, 0.433536565]], [[0.0, 0.0794483182], [0.0794483182, 0.0]]], [[[0.0, 0.0794483182], [0.0794483182, 0.0]], [[0.433536565, 0.0], [0.0, 0.385524695]]]]) assert np.allclose(q_molecule_reduced.mo_onee_ints, expected_mo_onee_ints) assert np.allclose(q_molecule_reduced.mo_eri_ints, expected_mo_eri_ints) assert np.isclose( q_molecule_reduced.energy_shift['ActiveSpaceTransformer'], 0.0)
def test_arbitrary_active_orbitals(self): """Test manual selection of active orbital indices.""" driver = HDF5Driver( hdf5_input=self.get_resource_path('H2_631g.hdf5', 'transformers')) q_molecule = driver.run() trafo = ActiveSpaceTransformer(num_electrons=2, num_orbitals=2, active_orbitals=[0, 2]) q_molecule_reduced = trafo.transform(q_molecule) expected_mo_onee_ints = np.asarray([[-1.24943841, -0.16790838], [-0.16790838, -0.18307469]]) expected_mo_eri_ints = np.asarray([[[[0.65209847, 0.16790822], [0.16790822, 0.53250905]], [[0.16790822, 0.10962908], [0.10962908, 0.11981429]]], [[[0.16790822, 0.10962908], [0.10962908, 0.11981429]], [[0.53250905, 0.11981429], [0.11981429, 0.46345617]]]]) assert np.allclose(q_molecule_reduced.mo_onee_ints, expected_mo_onee_ints) assert np.allclose(q_molecule_reduced.mo_eri_ints, expected_mo_eri_ints) assert np.isclose( q_molecule_reduced.energy_shift['ActiveSpaceTransformer'], 0.0)
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 setUp(self): super().setUp() self.skipTest("Skip test until refactored.") self.reference_energy = -1.1373060356951838 self.seed = 700 algorithm_globals.random_seed = self.seed self.driver = HDF5Driver(self.get_resource_path('test_driver_hdf5.hdf5', 'drivers/hdf5d')) fermionic_transformation = \ FermionicTransformation(qubit_mapping=FermionicQubitMappingType.PARITY, two_qubit_reduction=False) self.qubit_op, _ = fermionic_transformation.transform(self.driver) self.fermionic_transformation = fermionic_transformation self.optimizer = SLSQP(maxiter=100) initial_state = HartreeFock( fermionic_transformation.molecule_info['num_orbitals'], fermionic_transformation.molecule_info['num_particles'], qubit_mapping=fermionic_transformation._qubit_mapping, two_qubit_reduction=fermionic_transformation._two_qubit_reduction) self.var_form = UCCSD( num_orbitals=fermionic_transformation.molecule_info['num_orbitals'], num_particles=fermionic_transformation.molecule_info['num_particles'], initial_state=initial_state, qubit_mapping=fermionic_transformation._qubit_mapping, two_qubit_reduction=fermionic_transformation._two_qubit_reduction)
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/' 'molecular/resources') expected_fermionic_op = read_expected_file(expected_fermionic_op_path) driver = HDF5Driver( hdf5_input=self.get_resource_path('H2_631g.hdf5', 'transformers')) molecular_problem = MolecularProblem(driver) second_quantized_ops = molecular_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.fermion.to_list())) assert electr_sec_quant_op.boson is None assert electr_sec_quant_op.spin == {}
def test_error_raising(self, num_electrons, num_molecular_orbitals, active_orbitals, message): """Test errors are being raised in certain scenarios.""" driver = HDF5Driver(hdf5_input=self.get_resource_path('H2_sto3g.hdf5', 'transformers')) q_molecule = driver.run() with self.assertRaises(QiskitNatureError, msg=message): ActiveSpaceTransformer(num_electrons=num_electrons, num_molecular_orbitals=num_molecular_orbitals, active_orbitals=active_orbitals).transform(q_molecule)
def setUp(self): super().setUp() driver = HDF5Driver(hdf5_input=self.get_resource_path('test_driver_hdf5.hdf5', 'drivers/hdf5d')) fermionic_transformation = \ FermionicTransformation(transformation=FermionicTransformationType.FULL, qubit_mapping=FermionicQubitMappingType.PARITY, two_qubit_reduction=True, freeze_core=False, orbital_reduction=[]) self.qubit_op, self.aux_ops = fermionic_transformation.transform(driver) self.reference_energy = -1.857275027031588
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_full_active_space(self, kwargs): """Test that transformer has no effect when all orbitals are active.""" driver = HDF5Driver(hdf5_input=self.get_resource_path('H2_sto3g.hdf5', 'transformers')) q_molecule = driver.run() q_molecule.energy_shift['ActiveSpaceTransformer'] = 0.0 q_molecule.x_dip_energy_shift['ActiveSpaceTransformer'] = 0.0 q_molecule.y_dip_energy_shift['ActiveSpaceTransformer'] = 0.0 q_molecule.z_dip_energy_shift['ActiveSpaceTransformer'] = 0.0 trafo = ActiveSpaceTransformer(**kwargs) q_molecule_reduced = trafo.transform(q_molecule) self.assertQMolecule(q_molecule_reduced, q_molecule)
def setUp(self): super().setUp() self.driver = HDF5Driver(self.get_resource_path('test_driver_hdf5.hdf5', 'drivers/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_active_space_for_q_molecule_v2(self): """Test based on QMolecule v2 (mo_occ not available).""" driver = HDF5Driver(hdf5_input=self.get_resource_path('H2_sto3g_v2.hdf5', 'transformers')) q_molecule = driver.run() q_molecule.energy_shift['ActiveSpaceTransformer'] = 0.0 q_molecule.x_dip_energy_shift['ActiveSpaceTransformer'] = 0.0 q_molecule.y_dip_energy_shift['ActiveSpaceTransformer'] = 0.0 q_molecule.z_dip_energy_shift['ActiveSpaceTransformer'] = 0.0 trafo = ActiveSpaceTransformer(num_electrons=2, num_molecular_orbitals=2) q_molecule_reduced = trafo.transform(q_molecule) self.assertQMolecule(q_molecule_reduced, q_molecule)
def test_unpaired_electron_active_space(self): """Test an active space with an unpaired electron.""" driver = HDF5Driver(hdf5_input=self.get_resource_path( 'BeH_sto3g.hdf5', 'transformers')) q_molecule = driver.run() trafo = ActiveSpaceTransformer(num_electrons=3, num_orbitals=3, num_alpha=2) q_molecule_reduced = trafo.transform(q_molecule) expected_mo_onee_ints = np.asarray([[-1.30228816, 0.03573328, 0.0], [0.03573328, -0.86652349, 0.0], [0.0, 0.0, -0.84868407]]) expected_mo_eri_ints = np.asarray([[[[0.57237421, -0.05593597, 0.0], [-0.05593597, 0.30428426, 0.0], [0.0, 0.0, 0.36650821]], [[-0.05593597, 0.01937529, 0.0], [0.01937529, 0.02020237, 0.0], [0.0, 0.0, 0.01405676]], [[0.0, 0.0, 0.03600701], [0.0, 0.0, 0.028244], [0.03600701, 0.028244, 0.0]]], [[[-0.05593597, 0.01937529, 0.0], [0.01937529, 0.02020237, 0.0], [0.0, 0.0, 0.01405676]], [[0.30428426, 0.02020237, 0.0], [0.02020237, 0.48162669, 0.0], [0.0, 0.0, 0.40269913]], [[0.0, 0.0, 0.028244], [0.0, 0.0, 0.0564951], [0.028244, 0.0564951, 0.0]]], [[[0.0, 0.0, 0.03600701], [0.0, 0.0, 0.028244], [0.03600701, 0.028244, 0.0]], [[0.0, 0.0, 0.028244], [0.0, 0.0, 0.0564951], [0.028244, 0.0564951, 0.0]], [[0.36650821, 0.01405676, 0.0], [0.01405676, 0.40269913, 0.0], [0.0, 0.0, 0.44985904]]]]) assert np.allclose(q_molecule_reduced.mo_onee_ints, expected_mo_onee_ints) assert np.allclose(q_molecule_reduced.mo_eri_ints, expected_mo_eri_ints) assert np.isclose( q_molecule_reduced.energy_shift['ActiveSpaceTransformer'], -14.2538029231)
def setUp(self): super().setUp() algorithm_globals.random_seed = 42 driver = HDF5Driver(hdf5_input=self.get_resource_path('test_driver_hdf5.hdf5', 'drivers/hdf5d')) problem = ElectronicStructureProblem(driver) second_q_ops = problem.second_q_ops() converter = QubitConverter(mapper=ParityMapper(), two_qubit_reduction=True) num_particles = (problem.molecule_data_transformed.num_alpha, problem.molecule_data_transformed.num_beta) self.qubit_op = converter.convert(second_q_ops[0], num_particles) self.aux_ops = converter.convert_match(second_q_ops[1:]) self.reference_energy = -1.857275027031588
def test_mapping(self): """ Test mapping to qubit operator """ driver = HDF5Driver(hdf5_input=self.get_resource_path('test_driver_hdf5.hdf5', 'drivers/hdf5d')) q_molecule = driver.run() fermionic_op = fermionic_op_builder._build_fermionic_op(q_molecule) mapper = JordanWignerMapper() qubit_op = mapper.map(fermionic_op) # Note: The PauliSumOp equals, as used in the test below, use the equals of the # SparsePauliOp which in turn uses np.allclose() to determine equality of # coeffs. So the reference operator above will be matched on that basis so # we don't need to worry about tiny precision changes for any reason. self.assertEqual(qubit_op, TestJordanWignerMapper.REF_H2)
def test_active_space_for_q_molecule_v2(self): """Test based on QMolecule v2 (mo_occ not available).""" driver = HDF5Driver(hdf5_input=self.get_resource_path( 'H2_sto3g_v2.hdf5', 'transformers')) q_molecule = driver.run() trafo = ActiveSpaceTransformer(num_electrons=2, num_orbitals=2) q_molecule_reduced = trafo.transform(q_molecule) assert np.allclose(q_molecule_reduced.mo_onee_ints, q_molecule.mo_onee_ints) assert np.allclose(q_molecule_reduced.mo_eri_ints, q_molecule.mo_eri_ints) assert np.isclose( q_molecule_reduced.energy_shift['ActiveSpaceTransformer'], 0.0)
def test_full_active_space(self): """Test that transformer has no effect when all orbitals are active.""" driver = HDF5Driver( hdf5_input=self.get_resource_path('H2_sto3g.hdf5', 'transformers')) q_molecule = driver.run() trafo = ActiveSpaceTransformer(num_electrons=2, num_orbitals=2) q_molecule_reduced = trafo.transform(q_molecule) assert np.allclose(q_molecule_reduced.mo_onee_ints, q_molecule.mo_onee_ints) assert np.allclose(q_molecule_reduced.mo_eri_ints, q_molecule.mo_eri_ints) assert np.isclose( q_molecule_reduced.energy_shift['ActiveSpaceTransformer'], 0.0)
def test_full_active_space(self, kwargs): """Test that transformer has no effect when all orbitals are active.""" driver = HDF5Driver(hdf5_input=self.get_resource_path('H2_sto3g.hdf5', 'transformers')) q_molecule = driver.run() # The references which we compare too were produced by the `ActiveSpaceTransformer` and, # thus, the key here needs to stay the same as in that test case. q_molecule.energy_shift['ActiveSpaceTransformer'] = 0.0 q_molecule.x_dip_energy_shift['ActiveSpaceTransformer'] = 0.0 q_molecule.y_dip_energy_shift['ActiveSpaceTransformer'] = 0.0 q_molecule.z_dip_energy_shift['ActiveSpaceTransformer'] = 0.0 trafo = FreezeCoreTransformer(**kwargs) q_molecule_reduced = trafo.transform(q_molecule) self.assertQMolecule(q_molecule_reduced, q_molecule, dict_key='FreezeCoreTransformer')
def test_build_fermionic_op(self): """Tests that the correct FermionicOp is built from QMolecule.""" expected_num_of_terms_ferm_op = 184 expected_fermionic_op_path = self.get_resource_path('H2_631g_ferm_op_two_ints', 'problems/second_quantization/' 'molecular/resources') expected_fermionic_op = read_expected_file(expected_fermionic_op_path) driver = HDF5Driver(hdf5_input=self.get_resource_path('H2_631g.hdf5', 'transformers')) q_molecule = driver.run() fermionic_op = fermionic_op_builder.build_fermionic_op(q_molecule) with self.subTest("Check type of fermionic operator"): assert isinstance(fermionic_op, FermionicOp) with self.subTest("Check expected number of terms in a fermionic operator."): assert len(fermionic_op) == expected_num_of_terms_ferm_op with self.subTest("Check expected content of a fermionic operator."): assert all(s[0] == t[0] and np.isclose(s[1], t[1]) for s, t in zip(fermionic_op.to_list(), expected_fermionic_op))
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_build_fermionic_op_from_ints_both(self): """Tests that the correct FermionicOp is built from 1- and 2-body integrals.""" expected_num_of_terms_ferm_op = 184 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")) q_molecule = driver.run() fermionic_op = fermionic_op_builder.build_ferm_op_from_ints( q_molecule.one_body_integrals, q_molecule.two_body_integrals) with self.subTest("Check type of fermionic operator"): assert isinstance(fermionic_op, FermionicOp) with self.subTest( "Check expected number of terms in a fermionic operator."): assert len(fermionic_op) == expected_num_of_terms_ferm_op with self.subTest("Check expected content of a fermionic operator."): assert all( s[0] == t[0] and np.isclose(s[1], t[1]) for s, t in zip(fermionic_op.to_list(), expected_fermionic_op))