def test_mapping(self): """Test mapping to qubit operator""" driver = HDF5Driver(hdf5_input=self.get_resource_path( "test_driver_hdf5.hdf5", "drivers/second_quantization/hdf5d")) driver_result = driver.run() fermionic_op = driver_result.second_q_ops()["ElectronicEnergy"] 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_return_groundstate(self): """Test the VQEClient yields a ground state solver that returns the ground state.""" for use_deprecated in [False, True]: vqe, _ = self.get_standard_program(use_deprecated=use_deprecated) qubit_converter = QubitConverter(JordanWignerMapper()) gss = GroundStateEigensolver(qubit_converter, vqe) self.assertTrue(gss.returns_groundstate)
def test_fermionic_gaussian_state(self): """Test preparing fermionic Gaussian states.""" n_orbitals = 5 converter = QubitConverter(JordanWignerMapper()) quad_ham = random_quadratic_hamiltonian(n_orbitals, seed=5957) ( transformation_matrix, orbital_energies, transformed_constant, ) = quad_ham.diagonalizing_bogoliubov_transform() fermionic_op = quad_ham.to_fermionic_op() qubit_op = converter.convert(fermionic_op) matrix = qubit_op.to_matrix() occupied_orbitals_lists = [ [], [0], [3], [0, 1], [2, 4], [1, 3, 4], range(n_orbitals), ] for occupied_orbitals in occupied_orbitals_lists: circuit = FermionicGaussianState(transformation_matrix, occupied_orbitals, qubit_converter=converter) final_state = np.array(Statevector(circuit)) eig = np.sum( orbital_energies[occupied_orbitals]) + transformed_constant np.testing.assert_allclose(matrix @ final_state, eig * final_state, atol=1e-7)
def test_z2_symmetry(self): """Test mapping to qubit operator with z2 symmetry tapering""" z2_sector = [-1, 1, -1] def finder(z2_symmetries: Z2Symmetries) -> Optional[List[int]]: return z2_sector if not z2_symmetries.is_empty() else None def find_none(_z2_symmetries: Z2Symmetries) -> Optional[List[int]]: return None mapper = JordanWignerMapper() qubit_conv = QubitConverter(mapper, z2symmetry_reduction="auto") with self.subTest( "Locator returns None, should be untapered operator"): qubit_op = qubit_conv.convert(self.h2_op, sector_locator=find_none) self.assertEqual(qubit_op, TestQubitConverter.REF_H2_JW) qubit_op = qubit_conv.convert(self.h2_op, sector_locator=finder) self.assertEqual(qubit_op, TestQubitConverter.REF_H2_JW_TAPERED) with self.subTest("convert_match()"): qubit_op = qubit_conv.convert_match(self.h2_op) self.assertEqual(qubit_op, TestQubitConverter.REF_H2_JW_TAPERED) self.assertIsNone(qubit_conv.num_particles) self.assertListEqual(qubit_conv.z2symmetries.tapering_values, z2_sector)
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.reference_energies = [ -1.8427016, -1.8427016 + 0.5943372, -1.8427016 + 0.95788352, -1.8427016 + 1.5969296 ] self.qubit_converter = QubitConverter(JordanWignerMapper()) self.electronic_structure_problem = ElectronicStructureProblem( self.driver) solver = NumPyEigensolver() self.ref = solver self.quantum_instance = QuantumInstance( BasicAer.get_backend('statevector_simulator'), seed_transpiler=90, seed_simulator=12)
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.reference_energies = [ -1.8427016, -1.8427016 + 0.5943372, -1.8427016 + 0.95788352, -1.8427016 + 1.5969296, ] self.qubit_converter = QubitConverter(JordanWignerMapper()) self.electronic_structure_problem = ElectronicStructureProblem( self.driver) solver = NumPyEigensolver() self.ref = solver self.quantum_instance = QuantumInstance( BasicAer.get_backend("statevector_simulator"), seed_transpiler=90, seed_simulator=12, )
def __init__( self, transformation_matrix: np.ndarray, qubit_converter: Optional[QubitConverter] = None, validate: bool = True, rtol: float = 1e-5, atol: float = 1e-8, **circuit_kwargs, ) -> None: r""" Args: transformation_matrix: The matrix :math:`W` that specifies the coefficients of the new creation operators in terms of the original creation operators. Should be either :math:`N \times N` or :math:`N \times 2N`. qubit_converter: The qubit converter. The default behavior is to create one using the call `QubitConverter(JordanWignerMapper())`. validate: Whether to validate the inputs. rtol: Relative numerical tolerance for input validation. atol: Absolute numerical tolerance for input validation. circuit_kwargs: Keyword arguments to pass to the QuantumCircuit initializer. Raises: ValueError: transformation_matrix must be a 2-dimensional array. ValueError: transformation_matrix must have orthonormal rows. ValueError: transformation_matrix does not describe a valid transformation of fermionic ladder operators. If the transformation matrix is :math:`N \times N`, then it should be unitary. If the transformation matrix is :math:`N \times 2N`, then it should have the block form :math:`(W_1 \quad W_2)` where :math:`W_1 W_1^\dagger + W_2 W_2^\dagger = I` and :math:`W_1 W_2^T + W_2 W_1^T = 0`. NotImplementedError: Currently, only the Jordan-Wigner Transform is supported. Please use :class:`qiskit_nature.mappers.second_quantization.JordanWignerMapper` to construct the qubit mapper. """ if validate: _validate_transformation_matrix(transformation_matrix, rtol=rtol, atol=atol) if qubit_converter is None: qubit_converter = QubitConverter(JordanWignerMapper()) n, _ = transformation_matrix.shape register = QuantumRegister(n) super().__init__(register, **circuit_kwargs) if isinstance(qubit_converter.mapper, JordanWignerMapper): operations = _bogoliubov_transform_jw(register, transformation_matrix) for gate, qubits in operations: self.append(gate, qubits) else: raise NotImplementedError( "Currently, only the Jordan-Wigner Transform is supported. " "Please use " "qiskit_nature.mappers.second_quantization.JordanWignerMapper " "to construct the qubit mapper.")
def test_vqe_mes_jw_auto(self): """Test VQEUCCSDFactory with QEOM + Jordan Wigner mapping + auto symmetry""" self.skipTest( "Temporarily skip test until the changes done by " "https://github.com/Qiskit/qiskit-terra/pull/7551 are handled properly." ) converter = QubitConverter(JordanWignerMapper(), z2symmetry_reduction="auto") self._solve_with_vqe_mes(converter)
def test_puccd_ansatz(self, num_spin_orbitals, num_particles, expect): """Tests the PUCCD Ansatz.""" converter = QubitConverter(JordanWignerMapper()) ansatz = PUCCD(qubit_converter=converter, num_particles=num_particles, num_spin_orbitals=num_spin_orbitals) assert_ucc_like_ansatz(self, ansatz, num_spin_orbitals, expect)
def test_ucc_ansatz(self, excitations, num_spin_orbitals, num_particles, expect): """Tests the UCC Ansatz.""" converter = QubitConverter(JordanWignerMapper()) ansatz = UCC(qubit_converter=converter, num_particles=num_particles, num_spin_orbitals=num_spin_orbitals, excitations=excitations) assert_ucc_like_ansatz(self, ansatz, num_spin_orbitals, expect)
def test_puccd_ansatz_with_singles(self, num_spin_orbitals, num_particles, include_singles, expect): """Tests the PUCCD Ansatz with included single excitations.""" converter = QubitConverter(JordanWignerMapper()) ansatz = PUCCD(qubit_converter=converter, num_particles=num_particles, num_spin_orbitals=num_spin_orbitals, include_singles=include_singles) assert_ucc_like_ansatz(self, ansatz, num_spin_orbitals, expect)
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 setUp(self): super().setUp() self.converter = QubitConverter(JordanWignerMapper()) self.seed = 50 self.quantum_instance = QuantumInstance(BasicAer.get_backend('statevector_simulator'), shots=1, seed_simulator=self.seed, seed_transpiler=self.seed) self._vqe_ucc_factory = VQEUCCFactory(self.quantum_instance)
def __init__( self, transformation_matrix: np.ndarray, qubit_converter: Optional[QubitConverter] = None, validate: bool = True, rtol: float = 1e-5, atol: float = 1e-8, **circuit_kwargs, ) -> None: r""" Args: transformation_matrix: The matrix :math:`Q` that specifies the coefficients of the new creation operators in terms of the original creation operators. The rows of the matrix must be orthonormal. qubit_converter: The qubit converter. The default behavior is to create one using the call `QubitConverter(JordanWignerMapper())`. validate: Whether to validate the inputs. rtol: Relative numerical tolerance for input validation. atol: Absolute numerical tolerance for input validation. circuit_kwargs: Keyword arguments to pass to the QuantumCircuit initializer. Raises: ValueError: transformation_matrix must be a 2-dimensional array. ValueError: transformation_matrix must have orthonormal rows. NotImplementedError: Currently, only the Jordan-Wigner Transform is supported. Please use :class:`qiskit_nature.mappers.second_quantization.JordanWignerMapper` to construct the qubit mapper used to construct `qubit_converter`. """ if validate: _validate_transformation_matrix(transformation_matrix, rtol=rtol, atol=atol) if qubit_converter is None: qubit_converter = QubitConverter(JordanWignerMapper()) _, n = transformation_matrix.shape register = QuantumRegister(n) super().__init__(register, **circuit_kwargs) if isinstance(qubit_converter.mapper, JordanWignerMapper): operations = _prepare_slater_determinant_jw( register, transformation_matrix) for gate, qubits in operations: self.append(gate, qubits) else: raise NotImplementedError( "Currently, only the Jordan-Wigner Transform is supported. " "Please use " "qiskit_nature.mappers.second_quantization.JordanWignerMapper " "to construct the qubit mapper used to construct qubit_converter." )
def test_uccsd_ansatz_preserve_spin(self, num_spin_orbitals, num_particles, expect): """Tests UCCSD Ansatz with spin flips.""" converter = QubitConverter(JordanWignerMapper()) ansatz = UCCSD( qubit_converter=converter, num_particles=num_particles, num_spin_orbitals=num_spin_orbitals, preserve_spin=False, ) assert_ucc_like_ansatz(self, ansatz, num_spin_orbitals, expect)
def _run_driver(driver: FermionicDriver, converter: QubitConverter = QubitConverter( JordanWignerMapper()), transformers: Optional[List[BaseTransformer]] = None): problem = ElectronicStructureProblem(driver, transformers) solver = NumPyMinimumEigensolver() gsc = GroundStateEigensolver(converter, solver) result = gsc.solve(problem) return result
def test_uccsd_ansatz_generalized(self, num_spin_orbitals, num_particles, expect): """Tests the generalized UCCSD Ansatz.""" converter = QubitConverter(JordanWignerMapper()) ansatz = UCCSD( qubit_converter=converter, num_particles=num_particles, num_spin_orbitals=num_spin_orbitals, generalized=True, ) assert_ucc_like_ansatz(self, ansatz, num_spin_orbitals, expect)
def test_diagonalizing_bogoliubov_transform(self): """Test diagonalizing Bogoliubov transform.""" hermitian_part = np.array( [[0.0, 1.0, 0.0], [1.0, 0.0, 1.0], [0.0, 1.0, 0.0]], dtype=complex) antisymmetric_part = np.array( [[0.0, 1.0j, 0.0], [-1.0j, 0.0, 1.0j], [0.0, -1.0j, 0.0]], dtype=complex) quad_ham = QuadraticHamiltonian(hermitian_part, antisymmetric_part) ( transformation_matrix, orbital_energies, transformed_constant, ) = quad_ham.diagonalizing_bogoliubov_transform() # test that the transformation diagonalizes the Hamiltonian left = transformation_matrix[:, :3] right = transformation_matrix[:, 3:] full_transformation_matrix = np.block([[left, right], [right.conj(), left.conj()]]) eye = np.eye(3, dtype=complex) majorana_basis = np.block([[eye, eye], [1j * eye, -1j * eye] ]) / np.sqrt(2) basis_change = majorana_basis @ full_transformation_matrix @ majorana_basis.T.conj( ) majorana_matrix, majorana_constant = quad_ham.majorana_form() canonical = basis_change @ majorana_matrix @ basis_change.T zero = np.zeros((3, 3)) diagonal = np.diag(orbital_energies) expected = np.block([[zero, diagonal], [-diagonal, zero]]) np.testing.assert_allclose(orbital_energies, np.sort(orbital_energies)) np.testing.assert_allclose(canonical, expected, atol=1e-7) np.testing.assert_allclose( transformed_constant, majorana_constant - 0.5 * np.sum(orbital_energies)) # confirm eigenvalues match with Jordan-Wigner transformed Hamiltonian hamiltonian_jw = (QubitConverter(mapper=JordanWignerMapper()).convert( quad_ham.to_fermionic_op()).primitive.to_matrix()) eigs, _ = np.linalg.eigh(hamiltonian_jw) expected_eigs = np.array([ np.sum(orbital_energies[list(occupied_orbitals)]) + transformed_constant for occupied_orbitals in [(), (0, ), ( 1, ), (2, ), (0, 1), (0, 2), (1, 2), (0, 1, 2)] ]) np.testing.assert_allclose(np.sort(eigs), np.sort(expected_eigs), atol=1e-7)
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 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_custom_excitations(self, num_spin_orbitals, num_particles, excitations): """Tests if an error is raised when the excitations have a wrong format""" converter = QubitConverter(JordanWignerMapper()) # pylint: disable=unused-argument def custom_excitations(num_spin_orbitals, num_particles): return excitations with self.assertRaises(QiskitNatureError): ansatz = UCC( qubit_converter=converter, num_particles=num_particles, num_spin_orbitals=num_spin_orbitals, excitations=custom_excitations, ) ansatz.excitation_ops()
def test_transpile_no_parameters(self): """Test transpilation without parameters""" num_spin_orbitals = 8 num_particles = (2, 2) qubit_converter = QubitConverter(mapper=JordanWignerMapper()) ansatz = UCC( num_spin_orbitals=num_spin_orbitals, num_particles=num_particles, qubit_converter=qubit_converter, excitations="s", ) ansatz = transpile(ansatz, optimization_level=3) self.assertEqual(ansatz.num_qubits, 8)
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 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_h2_bopes_sampler_qeom(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) qeom_solver = QEOM(me_gsc, "sd") # BOPES sampler sampler = BOPESSampler(qeom_solver) # absolute internuclear distance in Angstrom points = [0.7, 1.0, 1.3] results = sampler.sample(problem, points) points_run = results.points energies = results.energies np.testing.assert_array_almost_equal(points_run, [0.7, 1.0, 1.3]) np.testing.assert_array_almost_equal( energies, [ [-1.13618945, -0.47845306, -0.1204519, 0.5833141], [-1.10115033, -0.74587179, -0.35229063, 0.03904763], [-1.03518627, -0.85523694, -0.42240202, -0.21860355], ], decimal=2, )
def test_mapping_basic(self): """Test mapping to qubit operator""" mapper = JordanWignerMapper() qubit_conv = QubitConverter(mapper) qubit_op = qubit_conv.convert(self.h2_op) self.assertIsInstance(qubit_op, PauliSumOp) # 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, TestQubitConverter.REF_H2_JW) with self.subTest("Re-use test"): qubit_op = qubit_conv.convert(self.h2_op) self.assertEqual(qubit_op, TestQubitConverter.REF_H2_JW) with self.subTest("convert_match()"): qubit_op = qubit_conv.convert_match(self.h2_op) self.assertEqual(qubit_op, TestQubitConverter.REF_H2_JW) with self.subTest("Re-use with different mapper"): qubit_conv.mapper = ParityMapper() qubit_op = qubit_conv.convert(self.h2_op) self.assertEqual(qubit_op, TestQubitConverter.REF_H2_PARITY) with self.subTest( "Set two qubit reduction - no effect without num particles"): qubit_conv.two_qubit_reduction = True qubit_op = qubit_conv.convert_match(self.h2_op) self.assertEqual(qubit_op, TestQubitConverter.REF_H2_PARITY) with self.subTest("Force match set num particles"): qubit_conv.force_match(self.num_particles) qubit_op = qubit_conv.convert_match(self.h2_op) self.assertEqual(qubit_op, TestQubitConverter.REF_H2_PARITY_2Q_REDUCED)
def test_slater_determinant(self): """Test preparing Slater determinants.""" n_orbitals = 5 converter = QubitConverter(JordanWignerMapper()) quad_ham = random_quadratic_hamiltonian(n_orbitals, num_conserving=True, seed=8839) ( transformation_matrix, orbital_energies, transformed_constant, ) = quad_ham.diagonalizing_bogoliubov_transform() fermionic_op = quad_ham.to_fermionic_op() qubit_op = converter.convert(fermionic_op) matrix = qubit_op.to_matrix() for n_particles in range(n_orbitals + 1): circuit = SlaterDeterminant(transformation_matrix[:n_particles], qubit_converter=converter) final_state = np.array(Statevector(circuit)) eig = np.sum(orbital_energies[:n_particles]) + transformed_constant np.testing.assert_allclose(matrix @ final_state, eig * final_state, atol=1e-7)
def test_vqe_bootstrap(self): """Test with VQE and bootstrapping.""" qubit_converter = QubitConverter(JordanWignerMapper()) 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) vqe_gse = GroundStateEigensolver(qubit_converter, solver) distance1 = partial(Molecule.absolute_distance, atom_pair=(1, 0)) mol = Molecule( geometry=[("H", [0.0, 0.0, 0.0]), ("H", [0.0, 0.0, 0.6])], degrees_of_freedom=[distance1], ) driver = ElectronicStructureMoleculeDriver( mol, driver_type=ElectronicStructureDriverType.PYSCF) es_problem = ElectronicStructureProblem(driver) points = list(np.linspace(0.6, 0.8, 4)) bopes = BOPESSampler(vqe_gse, bootstrap=True, num_bootstrap=None, extrapolator=None) result = bopes.sample(es_problem, points) ref_points = [0.6, 0.6666666666666666, 0.7333333333333334, 0.8] ref_energies = [ -1.1162738, -1.1326904, -1.1372876, -1.1341292, ] np.testing.assert_almost_equal(result.points, ref_points) np.testing.assert_almost_equal(result.energies, ref_energies)
def test_bogoliubov_transform(self, n_orbitals, num_conserving): """Test Bogoliubov transform.""" converter = QubitConverter(JordanWignerMapper()) hamiltonian = random_quadratic_hamiltonian( n_orbitals, num_conserving=num_conserving, seed=5740) ( transformation_matrix, orbital_energies, transformed_constant, ) = hamiltonian.diagonalizing_bogoliubov_transform() matrix = converter.map(hamiltonian.to_fermionic_op()).to_matrix() bog_circuit = BogoliubovTransform(transformation_matrix, qubit_converter=converter) for initial_state in range(2**n_orbitals): state = Statevector.from_int(initial_state, dims=2**n_orbitals) final_state = np.array(state.evolve(bog_circuit)) occupied_orbitals = [ i for i in range(n_orbitals) if initial_state >> i & 1 ] eig = np.sum( orbital_energies[occupied_orbitals]) + transformed_constant np.testing.assert_allclose(matrix @ final_state, eig * final_state, atol=1e-8)
def get_qubit_op(self, dist, mapper='jw'): # Use PySCF, a classical computational chemistry software # package, to compute the one-body and two-body integrals in # electronic-orbital basis, necessary to form the Fermionic operator driver = PySCFDriver(atom=self.molecule_name + str(dist), unit=UnitsType.ANGSTROM, charge=0, spin=0, basis='sto3g') molecule = driver.run() es_problem = ElectronicStructureProblem(driver) if mapper == 'jw': qubit_converter = QubitConverter(mapper=JordanWignerMapper()) elif mapper == 'parity': qubit_converter = QubitConverter(mapper=ParityMapper(), two_qubit_reduction=True) #second_q_ops = es_problem.second_q_ops() #num_particles = es_problem.num_particles #molecule_data = es_problem.molecule_data #electronic_operator = second_q_ops[0] return es_problem, qubit_converter, molecule.nuclear_repulsion_energy