def get_solver(self, problem, qubit_converter): particle_number = cast( ParticleNumber, problem.grouped_property_transformed.get_property( ParticleNumber), ) num_spin_orbitals = particle_number.num_spin_orbitals num_particles = (particle_number.num_alpha, particle_number.num_beta) initial_state = HartreeFock(num_spin_orbitals, num_particles, qubit_converter) ansatz = UCC( qubit_converter=qubit_converter, num_particles=num_particles, num_spin_orbitals=num_spin_orbitals, excitations="d", initial_state=initial_state, ) vqe = VQE( ansatz=ansatz, quantum_instance=self.minimum_eigensolver.quantum_instance, optimizer=L_BFGS_B(), ) return vqe
def setUp(self): super().setUp() # np.random.seed(50) self.seed = 50 algorithm_globals.random_seed = self.seed 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 molecule = self.driver.run() self.num_particles = molecule.num_alpha + molecule.num_beta self.num_spin_orbitals = molecule.num_orbitals * 2 fer_op = FermionicOperator(h1=molecule.one_body_integrals, h2=molecule.two_body_integrals) map_type = 'PARITY' qubit_op = fer_op.mapping(map_type) self.qubit_op = TwoQubitReduction( num_particles=self.num_particles).convert(qubit_op) self.num_qubits = self.qubit_op.num_qubits self.init_state = HartreeFock(self.num_spin_orbitals, self.num_particles) self.var_form_base = None
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)
def test_uccsd_hf_qpUCCD(self): """ paired uccd test """ optimizer = SLSQP(maxiter=100) initial_state = HartreeFock( self.fermionic_transformation.molecule_info['num_orbitals'], self.fermionic_transformation.molecule_info['num_particles'], qubit_mapping=self.fermionic_transformation._qubit_mapping, two_qubit_reduction=self.fermionic_transformation._two_qubit_reduction) var_form = UCCSD( num_orbitals=self.fermionic_transformation.molecule_info['num_orbitals'], num_particles=self.fermionic_transformation.molecule_info['num_particles'], active_occupied=None, active_unoccupied=None, initial_state=initial_state, qubit_mapping=self.fermionic_transformation._qubit_mapping, two_qubit_reduction=self.fermionic_transformation._two_qubit_reduction, num_time_slices=1, shallow_circuit_concat=False, method_doubles='pucc', excitation_type='d' ) solver = VQE(var_form=var_form, optimizer=optimizer, quantum_instance=QuantumInstance( backend=BasicAer.get_backend('statevector_simulator'))) gsc = GroundStateEigensolver(self.fermionic_transformation, solver) result = gsc.solve(self.driver) self.assertAlmostEqual(result.total_energies[0], self.reference_energy_pUCCD, places=6)
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_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)
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 run(self): numpy_solver = NumPyMinimumEigensolver() distances = np.arange(0.3, 2.0, 0.05) exact_energies = [] vqe_energies = [] n = len(distances) i = 1 for dist in distances: print("Distance %d/%d" % (i, n)) i += 1 es_problem, qubit_converter, nuclear_repulsion_energy = self.get_qubit_op( dist) second_q_ops = es_problem.second_q_ops() main_op = qubit_converter.convert( second_q_ops[0], num_particles=es_problem.num_particles, sector_locator=es_problem.symmetry_sector_locator) aux_ops = qubit_converter.convert_match(second_q_ops[1:]) q_molecule_transformed = cast(QMolecule, es_problem.molecule_data_transformed) num_molecular_orbitals = q_molecule_transformed.num_molecular_orbitals num_particles = (q_molecule_transformed.num_alpha, q_molecule_transformed.num_beta) num_spin_orbitals = 2 * num_molecular_orbitals # Initial state is Hartree Fock state initial_state = HartreeFock(num_spin_orbitals, num_particles, qubit_converter) # UCCSD ansatz for unitary update ansatz = UCCSD() ansatz.qubit_converter = qubit_converter ansatz.num_particles = num_particles ansatz.num_spin_orbitals = num_spin_orbitals ansatz.initial_state = initial_state self.vqe.ansatz = ansatz solver = self.vqe print("Computing minimum eigenvalue...") # Approximate minimum eigenvalue using VQE vqe_result = solver.compute_minimum_eigenvalue(main_op) print(np.real(vqe_result.eigenvalue) + nuclear_repulsion_energy) #exact_result = numpy_solver.compute_minimum_eigenvalue(main_op) vqe_energies.append( np.real(vqe_result.eigenvalue) + nuclear_repulsion_energy) #exact_energies.append(np.real(exact_result.eigenvalue) + nuclear_repulsion_energy) #print("Interatomic Distance:", np.round(dist, 2), "VQE Result:", vqe_result, "Exact Energy:", exact_energies[-1]) return (distances, vqe_energies, exact_energies)
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 get_solver(self, problem: ElectronicStructureProblem, # type: ignore[override] qubit_converter: QubitConverter) -> MinimumEigensolver: """Returns a VQE with a UCCSD wavefunction ansatz, based on ``transformation``. This works only with a ``FermionicTransformation``. Args: problem: a class encoding a problem to be solved. qubit_converter: a class that converts second quantized operator to qubit operator according to a mapper it is initialized with. Returns: A VQE suitable to compute the ground state of the molecule transformed by ``transformation``. """ q_molecule_transformed = cast(QMolecule, problem.molecule_data_transformed) num_molecular_orbitals = q_molecule_transformed.num_molecular_orbitals num_particles = (q_molecule_transformed.num_alpha, q_molecule_transformed.num_beta) num_spin_orbitals = 2 * num_molecular_orbitals initial_state = self.initial_state if initial_state is None: initial_state = HartreeFock(num_spin_orbitals, num_particles, qubit_converter) ansatz = self.ansatz if ansatz is None: ansatz = UCCSD() ansatz.qubit_converter = qubit_converter ansatz.num_particles = num_particles ansatz.num_spin_orbitals = num_spin_orbitals ansatz.initial_state = initial_state self._vqe.ansatz = ansatz return self._vqe
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_qubits_2_py_h2(self): """ qubits 2 py h2 test """ num_particles = (1, 1) converter = QubitConverter(ParityMapper(), two_qubit_reduction=True) converter.force_match(num_particles=num_particles) state = HartreeFock(4, num_particles, converter) ref = QuantumCircuit(2) ref.x(0) self.assertEqual(state, ref)
def get_solver(self, transformation): num_orbitals = transformation.molecule_info['num_orbitals'] num_particles = transformation.molecule_info['num_particles'] initial_state = HartreeFock(num_orbitals, num_particles) var_form = UCCSD(num_orbitals, num_particles, initial_state=initial_state) vqe = VQE(var_form=var_form, quantum_instance=self._quantum_instance, optimizer=L_BFGS_B()) return vqe
def test_uccsd_hf_excitations(self): """ uccsd tapering test using all double excitations """ # initial state init_state = HartreeFock( num_orbitals=self.fermionic_transformation.molecule_info['num_orbitals'], qubit_mapping=self.fermionic_transformation._qubit_mapping, two_qubit_reduction=self.fermionic_transformation._two_qubit_reduction, num_particles=self.fermionic_transformation.molecule_info['num_particles'], sq_list=self.fermionic_transformation.molecule_info['z2_symmetries'].sq_list) # check singlet excitations var_form = UCCSD( num_orbitals=self.fermionic_transformation.molecule_info['num_orbitals'], num_particles=self.fermionic_transformation.molecule_info['num_particles'], active_occupied=None, active_unoccupied=None, initial_state=init_state, qubit_mapping=self.fermionic_transformation._qubit_mapping, two_qubit_reduction=self.fermionic_transformation._two_qubit_reduction, num_time_slices=1, z2_symmetries=self.fermionic_transformation.molecule_info['z2_symmetries'], shallow_circuit_concat=False, method_doubles='succ', excitation_type='d', skip_commute_test=True) double_excitations_singlet = var_form._double_excitations res = TestUCCSDHartreeFock.excitation_lists_comparator( double_excitations_singlet, self.reference_singlet_double_excitations) self.assertEqual(res, True) # check grouped singlet excitations var_form = UCCSD( num_orbitals=self.fermionic_transformation.molecule_info['num_orbitals'], num_particles=self.fermionic_transformation.molecule_info['num_particles'], active_occupied=None, active_unoccupied=None, initial_state=init_state, qubit_mapping=self.fermionic_transformation._qubit_mapping, two_qubit_reduction=self.fermionic_transformation._two_qubit_reduction, num_time_slices=1, z2_symmetries=self.fermionic_transformation.molecule_info['z2_symmetries'], shallow_circuit_concat=False, method_doubles='succ_full', excitation_type='d', skip_commute_test=True) double_excitations_singlet_grouped = var_form._double_excitations_grouped res_groups = TestUCCSDHartreeFock.group_excitation_lists_comparator( double_excitations_singlet_grouped, self.reference_singlet_groups) self.assertEqual(res_groups, True)
def get_solver( # type: ignore[override] self, problem: ElectronicStructureProblem, qubit_converter: QubitConverter, ) -> MinimumEigensolver: """Returns a VQE with a UCCSD wavefunction ansatz, based on ``qubit_converter``. Args: problem: a class encoding a problem to be solved. qubit_converter: a class that converts second quantized operator to qubit operator according to a mapper it is initialized with. Returns: A VQE suitable to compute the ground state of the molecule. """ driver_result = problem.grouped_property_transformed particle_number = cast(ParticleNumber, driver_result.get_property(ParticleNumber)) num_spin_orbitals = particle_number.num_spin_orbitals num_particles = particle_number.num_alpha, particle_number.num_beta initial_state = self.initial_state if initial_state is None: initial_state = HartreeFock(num_spin_orbitals, num_particles, qubit_converter) ansatz = self.ansatz if ansatz is None: ansatz = UCCSD() ansatz.qubit_converter = qubit_converter ansatz.num_particles = num_particles ansatz.num_spin_orbitals = num_spin_orbitals ansatz.initial_state = initial_state # TODO: leverage re-usability of VQE after fixing # https://github.com/Qiskit/qiskit-terra/issues/7093 vqe = VQE( ansatz=ansatz, quantum_instance=self.quantum_instance, optimizer=self.optimizer, initial_point=self.initial_point, gradient=self.gradient, expectation=self.expectation, include_custom=self.include_custom, callback=self.callback, **self._kwargs, ) return vqe
def test_uccsd_hf_qUCCSD(self): """ uccsd tapering test using all double excitations """ fermionic_transformation = FermionicTransformation( transformation=FermionicTransformationType.FULL, qubit_mapping=FermionicQubitMappingType.PARITY, two_qubit_reduction=True, freeze_core=True, orbital_reduction=[], z2symmetry_reduction='auto' ) qubit_op, _ = fermionic_transformation.transform(self.driver) # optimizer optimizer = SLSQP(maxiter=100) # initial state init_state = HartreeFock( num_orbitals=fermionic_transformation.molecule_info['num_orbitals'], qubit_mapping=fermionic_transformation._qubit_mapping, two_qubit_reduction=fermionic_transformation._two_qubit_reduction, num_particles=fermionic_transformation.molecule_info['num_particles'], sq_list=fermionic_transformation.molecule_info['z2_symmetries'].sq_list) var_form = UCCSD( num_orbitals=fermionic_transformation.molecule_info['num_orbitals'], num_particles=fermionic_transformation.molecule_info['num_particles'], active_occupied=None, active_unoccupied=None, initial_state=init_state, qubit_mapping=fermionic_transformation._qubit_mapping, two_qubit_reduction=fermionic_transformation._two_qubit_reduction, num_time_slices=1, z2_symmetries=fermionic_transformation.molecule_info['z2_symmetries'], shallow_circuit_concat=False, method_doubles='ucc', excitation_type='sd', skip_commute_test=True) solver = VQE(var_form=var_form, optimizer=optimizer, quantum_instance=QuantumInstance( backend=BasicAer.get_backend('statevector_simulator'))) raw_result = solver.compute_minimum_eigenvalue(qubit_op, None) result = fermionic_transformation.interpret(raw_result) self.assertAlmostEqual(result.total_energies[0], self.reference_energy_UCCSD, places=6)
def test_qubits_6_py_lih(self): """ qubits 6 py lih test """ num_particles = (1, 1) converter = QubitConverter(ParityMapper(), two_qubit_reduction=True) z2symmetries = Z2Symmetries( symmetries=[Pauli('ZIZIZIZI'), Pauli('ZZIIZZII')], sq_paulis=[Pauli('IIIIIIXI'), Pauli('IIIIIXII')], sq_list=[2, 3], tapering_values=[1, 1], ) converter.force_match(num_particles=num_particles, z2symmetries=z2symmetries) state = HartreeFock(10, num_particles, converter) ref = QuantumCircuit(6) ref.x([0, 1]) self.assertEqual(state, ref)
def test_setters_getters(self): """Test Getter/Setter""" with self.subTest("Quantum Instance"): self.assertEqual(self._vqe_ucc_factory.quantum_instance, self.quantum_instance) self._vqe_ucc_factory.quantum_instance = None self.assertEqual(self._vqe_ucc_factory.quantum_instance, None) with self.subTest("Optimizer"): self.assertEqual(self._vqe_ucc_factory.optimizer, None) optimizer = COBYLA() self._vqe_ucc_factory.optimizer = optimizer self.assertEqual(self._vqe_ucc_factory.optimizer, optimizer) with self.subTest("Initial Point"): self.assertEqual(self._vqe_ucc_factory.initial_point, None) initial_point = [1, 2, 3] self._vqe_ucc_factory.initial_point = initial_point self.assertEqual(self._vqe_ucc_factory.initial_point, initial_point) with self.subTest("Expectation"): self.assertEqual(self._vqe_ucc_factory.expectation, None) expectation = AerPauliExpectation() self._vqe_ucc_factory.expectation = expectation self.assertEqual(self._vqe_ucc_factory.expectation, expectation) with self.subTest("Include Custom"): self.assertEqual(self._vqe_ucc_factory.include_custom, False) self._vqe_ucc_factory.include_custom = True self.assertEqual(self._vqe_ucc_factory.include_custom, True) with self.subTest("Ansatz"): self.assertEqual(self._vqe_ucc_factory.ansatz, None) ansatz = UCCSD() self._vqe_ucc_factory.ansatz = ansatz self.assertTrue(isinstance(self._vqe_ucc_factory.ansatz, UCCSD)) with self.subTest("Initial State"): self.assertEqual(self._vqe_ucc_factory.initial_state, None) initial_state = HartreeFock(4, (1, 1), self.converter) self._vqe_ucc_factory.initial_state = initial_state self.assertEqual(self._vqe_ucc_factory.initial_state, initial_state)
def get_solver( # type: ignore[override] self, problem: ElectronicStructureProblem, qubit_converter: QubitConverter, ) -> MinimumEigensolver: """Returns a VQE with a UCCSD wavefunction ansatz, based on ``qubit_converter``. Args: problem: a class encoding a problem to be solved. qubit_converter: a class that converts second quantized operator to qubit operator according to a mapper it is initialized with. Returns: A VQE suitable to compute the ground state of the molecule. """ driver_result = problem.grouped_property_transformed particle_number = cast(ParticleNumber, driver_result.get_property(ParticleNumber)) num_spin_orbitals = particle_number.num_spin_orbitals num_particles = particle_number.num_alpha, particle_number.num_beta initial_state = self.initial_state if initial_state is None: initial_state = HartreeFock(num_spin_orbitals, num_particles, qubit_converter) ansatz = self.ansatz if ansatz is None: ansatz = UCCSD() ansatz.qubit_converter = qubit_converter ansatz.num_particles = num_particles ansatz.num_spin_orbitals = num_spin_orbitals ansatz.initial_state = initial_state self.minimum_eigensolver.ansatz = ansatz if isinstance(self.initial_point, InitialPoint): self.initial_point.ansatz = ansatz self.initial_point.grouped_property = driver_result initial_point = self.initial_point.to_numpy_array() else: initial_point = self.initial_point self.minimum_eigensolver.initial_point = initial_point return self.minimum_eigensolver
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 get_solver(self, problem, qubit_converter): q_molecule_transformed = cast( QMolecule, problem.molecule_data_transformed) num_molecular_orbitals = q_molecule_transformed.num_molecular_orbitals num_particles = (q_molecule_transformed.num_alpha, q_molecule_transformed.num_beta) num_spin_orbitals = 2 * num_molecular_orbitals initial_state = HartreeFock(num_spin_orbitals, num_particles, qubit_converter) ansatz = UCC(qubit_converter=qubit_converter, num_particles=num_particles, num_spin_orbitals=num_spin_orbitals, excitations='d', initial_state=initial_state) vqe = VQE(ansatz=ansatz, quantum_instance=self._quantum_instance, optimizer=L_BFGS_B()) return vqe
def get_solver(self, transformation): num_orbitals = transformation.molecule_info['num_orbitals'] num_particles = transformation.molecule_info['num_particles'] qubit_mapping = transformation.qubit_mapping two_qubit_reduction = transformation.molecule_info[ 'two_qubit_reduction'] z2_symmetries = transformation.molecule_info['z2_symmetries'] initial_state = HartreeFock(num_orbitals, num_particles, qubit_mapping, two_qubit_reduction, z2_symmetries.sq_list) var_form = UCCSD(num_orbitals=num_orbitals, num_particles=num_particles, initial_state=initial_state, qubit_mapping=qubit_mapping, two_qubit_reduction=two_qubit_reduction, z2_symmetries=z2_symmetries) vqe = VQE(var_form=var_form, quantum_instance=self._quantum_instance, optimizer=L_BFGS_B()) return vqe
def test_setters_getters(self): """Test Getter/Setter. These tests are using the getter/setter from the""" with self.subTest("Initial Point"): self.assertTrue(isinstance(self._vqe_ucc_factory.initial_point, HFInitialPoint)) initial_point = [1, 2, 3] self._vqe_ucc_factory.initial_point = initial_point self.assertEqual(self._vqe_ucc_factory.initial_point, initial_point) with self.subTest("Ansatz"): self.assertEqual(self._vqe_ucc_factory.ansatz, None) ansatz = UCCSD() self._vqe_ucc_factory.ansatz = ansatz self.assertTrue(isinstance(self._vqe_ucc_factory.ansatz, UCCSD)) with self.subTest("Initial State"): self.assertEqual(self._vqe_ucc_factory.initial_state, None) initial_state = HartreeFock(4, (1, 1), self.converter) self._vqe_ucc_factory.initial_state = initial_state self.assertEqual(self._vqe_ucc_factory.initial_state, initial_state)
def test_qubits_6_py_lih(self): """ qubits 6 py lih test """ state = HartreeFock(10, (1, 1), 'parity', True, [1, 2]) ref = QuantumCircuit(6) ref.x([0, 1]) self.assertEqual(state, ref)
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 import FermionicOperator from qiskit_nature.drivers import PySCFDriver, UnitsType from qiskit.opflow import TwoQubitReduction # Use PySCF, a classical computational chemistry software # package, to compute the one-body and two-body integrals in # molecular-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') molecule = driver.run() num_particles = molecule.num_alpha + molecule.num_beta num_spin_orbitals = molecule.num_orbitals * 2 # Build the qubit operator, which is the input to the VQE algorithm ferm_op = FermionicOperator(h1=molecule.one_body_integrals, h2=molecule.two_body_integrals) map_type = 'PARITY' qubit_op = ferm_op.mapping(map_type) qubit_op = TwoQubitReduction( num_particles=num_particles).convert(qubit_op) num_qubits = qubit_op.num_qubits # setup a classical optimizer for VQE from qiskit.algorithms.optimizers import L_BFGS_B optimizer = L_BFGS_B() # setup the initial state for the variational form from qiskit_nature.circuit.library import HartreeFock init_state = HartreeFock(num_spin_orbitals, num_particles) # setup the variational form for VQE from qiskit.circuit.library import TwoLocal var_form = TwoLocal(num_qubits, ['ry', 'rz'], 'cz') # add the initial state var_form.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(var_form, optimizer=optimizer, quantum_instance=backend) result = algorithm.compute_minimum_eigenvalue(qubit_op) print(result.eigenvalue.real) # ---------------------------------------------------------------------- self.assertAlmostEqual(result.eigenvalue.real, -1.8572750301938803, places=6)
def test_qubits_4_bk_h2(self): """ qubits 4 bk h2 test """ state = HartreeFock(4, (1, 1), QubitConverter(BravyiKitaevMapper())) ref = QuantumCircuit(4) ref.x([0, 1, 2]) self.assertEqual(state, ref)
def test_qubits_4_py_h2(self): """ qubits 4 py h2 test """ state = HartreeFock(4, (1, 1), QubitConverter(ParityMapper())) ref = QuantumCircuit(4) ref.x([0, 1]) self.assertEqual(state, ref)
def test_qubits_4_jw_h2(self): """ qubits 4 jw h2 test """ state = HartreeFock(4, (1, 1), QubitConverter(JordanWignerMapper())) ref = QuantumCircuit(4) ref.x([0, 2]) self.assertEqual(state, ref)
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)
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('aer_simulator_statevector') # setup and run VQE