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() 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_h2_bopes_sampler(self): """Test BOPES Sampler on H2""" seed = 50 algorithm_globals.random_seed = seed # Molecule dof = partial(Molecule.absolute_distance, atom_pair=(1, 0)) m = Molecule(geometry=[['H', [0., 0., 1.]], ['H', [0., 0.45, 1.]]], degrees_of_freedom=[dof]) mapper = ParityMapper() converter = QubitConverter(mapper=mapper, two_qubit_reduction=True) driver = PySCFDriver(molecule=m) problem = ElectronicStructureProblem(driver) solver = NumPyMinimumEigensolver() me_gss = GroundStateEigensolver(converter, solver) # BOPES sampler sampler = BOPESSampler(gss=me_gss) # 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, -1.10115033, -1.03518627], decimal=2)
def setUp(self): super().setUp() algorithm_globals.random_seed = 42 driver = HDF5Driver(hdf5_input=self.get_resource_path( "test_driver_hdf5.hdf5", "drivers/second_quantization/hdf5d")) problem = ElectronicStructureProblem(driver) second_q_ops = [problem.second_q_ops()[problem.main_property_name]] converter = QubitConverter(mapper=ParityMapper(), two_qubit_reduction=True) num_particles = ( problem.grouped_property_transformed.get_property( "ParticleNumber").num_alpha, problem.grouped_property_transformed.get_property( "ParticleNumber").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 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]]]
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_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 setUp(self): super().setUp() try: self.driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.735', unit=UnitsType.ANGSTROM, basis='sto3g') except QiskitNatureError: self.skipTest('PYSCF driver does not appear to be installed') return self.problem = ElectronicStructureProblem(self.driver) self.expected = -1.85727503 self.qubit_converter = QubitConverter(ParityMapper())
def test_potential_interface(self): """Tests potential interface.""" seed = 50 algorithm_globals.random_seed = seed stretch = partial(Molecule.absolute_distance, atom_pair=(1, 0)) # H-H molecule near equilibrium geometry m = Molecule(geometry=[ ['H', [0., 0., 0.]], ['H', [1., 0., 0.]], ], degrees_of_freedom=[stretch], masses=[1.6735328E-27, 1.6735328E-27]) mapper = ParityMapper() converter = QubitConverter(mapper=mapper) driver = PySCFDriver(molecule=m) problem = ElectronicStructureProblem(driver) solver = NumPyMinimumEigensolver() me_gss = GroundStateEigensolver(converter, solver) # Run BOPESSampler with exact eigensolution points = np.arange(0.45, 5.3, 0.3) sampler = BOPESSampler(gss=me_gss) res = sampler.sample(problem, points) # Testing Potential interface pot = MorsePotential(m) pot.fit(res.points, res.energies) np.testing.assert_array_almost_equal([pot.alpha, pot.r_0], [2.235, 0.720], decimal=3) np.testing.assert_array_almost_equal([pot.d_e, pot.m_shift], [0.2107, -1.1419], decimal=3)
from qiskit_nature.drivers import PySCFDriver, UnitsType from qiskit_nature.problems.second_quantization.electronic import ElectronicStructureProblem # 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='H .0 .0 .0; H .0 .0 0.735', unit=UnitsType.ANGSTROM, basis='sto3g') problem = ElectronicStructureProblem(driver) # generate the second-quantized operators second_q_ops = problem.second_q_ops() main_op = second_q_ops[0] num_particles = (problem.molecule_data_transformed.num_alpha, problem.molecule_data_transformed.num_beta) num_spin_orbitals = 2 * problem.molecule_data.num_molecular_orbitals # setup the classical optimizer for VQE from qiskit.algorithms.optimizers import L_BFGS_B optimizer = L_BFGS_B() # setup the mapper and qubit converter from qiskit_nature.mappers.second_quantization import ParityMapper from qiskit_nature.converters.second_quantization import QubitConverter mapper = ParityMapper() converter = QubitConverter(mapper=mapper, two_qubit_reduction=True)
def test_readme_sample(self): """ readme sample test """ # pylint: disable=import-outside-toplevel,redefined-builtin def print(*args): """ overloads print to log values """ if args: self.log.debug(args[0], *args[1:]) # --- Exact copy of sample code ---------------------------------------- from qiskit_nature.drivers import PySCFDriver, UnitsType from qiskit_nature.problems.second_quantization.electronic import ElectronicStructureProblem # 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='H .0 .0 .0; H .0 .0 0.735', unit=UnitsType.ANGSTROM, basis='sto3g') problem = ElectronicStructureProblem(driver) # generate the second-quantized operators second_q_ops = problem.second_q_ops() main_op = second_q_ops[0] num_particles = (problem.molecule_data_transformed.num_alpha, problem.molecule_data_transformed.num_beta) num_spin_orbitals = 2 * problem.molecule_data.num_molecular_orbitals # setup the classical optimizer for VQE from qiskit.algorithms.optimizers import L_BFGS_B optimizer = L_BFGS_B() # setup the mapper and qubit converter from qiskit_nature.mappers.second_quantization import ParityMapper from qiskit_nature.converters.second_quantization import QubitConverter mapper = ParityMapper() converter = QubitConverter(mapper=mapper, two_qubit_reduction=True) # map to qubit operators qubit_op = converter.convert(main_op, num_particles=num_particles) # setup the initial state for the ansatz from qiskit_nature.circuit.library import HartreeFock init_state = HartreeFock(num_spin_orbitals, num_particles, converter) # setup the ansatz for VQE from qiskit.circuit.library import TwoLocal ansatz = TwoLocal(num_spin_orbitals, ['ry', 'rz'], 'cz') # add the initial state ansatz.compose(init_state, front=True) # set the backend for the quantum computation from qiskit import Aer backend = Aer.get_backend('statevector_simulator') # setup and run VQE from qiskit.algorithms import VQE algorithm = VQE(ansatz, optimizer=optimizer, quantum_instance=backend) result = algorithm.compute_minimum_eigenvalue(qubit_op) print(result.eigenvalue.real) electronic_structure_result = problem.interpret(result) print(electronic_structure_result) # ---------------------------------------------------------------------- self.assertAlmostEqual(result.eigenvalue.real, -1.8572750301938803, places=6)
class TestUCCSDHartreeFock(QiskitNatureTestCase): """Test for these extensions.""" 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 """ 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 """ 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)