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 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_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)
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 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_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_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 _setup_evaluation_operators(self): # first we run a ground state calculation solver = VQEUCCSDFactory(QuantumInstance(BasicAer.get_backend('statevector_simulator'))) calc = GroundStateEigensolver(self.transformation, solver) res = calc.solve(self.driver) # now we decide that we want to evaluate another operator # for testing simplicity, we just use some pre-constructed auxiliary operators _, aux_ops = self.transformation.transform(self.driver) return calc, res, aux_ops
def test_uccsd_hf(self): """ uccsd hf test """ backend = BasicAer.get_backend('statevector_simulator') solver = VQE(var_form=self.var_form, optimizer=self.optimizer, quantum_instance=QuantumInstance(backend=backend)) gsc = GroundStateEigensolver(self.fermionic_transformation, solver) result = gsc.solve(self.driver) self.assertAlmostEqual(result.total_energies[0], self.reference_energy, places=6)
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_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 _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_aux_ops_reusability(self): """ Test that the auxiliary operators can be reused """ # Regression test against #1475 solver = NumPyMinimumEigensolverFactory() calc = GroundStateEigensolver(self.transformation, solver) modes = 4 h_1 = np.eye(modes, dtype=complex) h_2 = np.zeros((modes, modes, modes, modes)) aux_ops = [FermionicOperator(h_1, h_2)] aux_ops_copy = copy.deepcopy(aux_ops) _ = calc.solve(self.driver, aux_ops) assert all(a == b for a, b in zip(aux_ops, aux_ops_copy))
def test_uccsd_hf_qasm(self): """ uccsd hf test with qasm_simulator. """ backend = BasicAer.get_backend('qasm_simulator') optimizer = SPSA(maxiter=200, last_avg=5) solver = VQE(var_form=self.var_form, optimizer=optimizer, expectation=PauliExpectation(), quantum_instance=QuantumInstance( backend=backend, seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed)) gsc = GroundStateEigensolver(self.fermionic_transformation, solver) result = gsc.solve(self.driver) self.assertAlmostEqual(result.total_energies[0], -1.138, places=2)
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 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 solver = VQE(var_form=self.var_form, optimizer=self.optimizer, quantum_instance=QuantumInstance(backend=backend)) gsc = GroundStateEigensolver(self.fermionic_transformation, solver) result = gsc.solve(self.driver) self.assertAlmostEqual(result.total_energies[0], self.reference_energy, places=6)
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]) f_t = FermionicTransformation() driver = PySCFDriver(molecule=m) f_t.transform(driver) solver = NumPyMinimumEigensolver() me_gss = GroundStateEigensolver(f_t, solver) # Run BOPESSampler with exact eigensolution points = np.arange(0.45, 5.3, 0.3) sampler = BOPESSampler(gss=me_gss) res = sampler.sample(driver, 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)
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_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 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)
def _run_driver(driver, transformation=FermionicTransformationType.FULL, qubit_mapping=FermionicQubitMappingType.JORDAN_WIGNER, two_qubit_reduction=False, freeze_core=True): fermionic_transformation = \ FermionicTransformation(transformation=transformation, qubit_mapping=qubit_mapping, two_qubit_reduction=two_qubit_reduction, freeze_core=freeze_core, orbital_reduction=[]) solver = NumPyMinimumEigensolver() gsc = GroundStateEigensolver(fermionic_transformation, solver) result = gsc.solve(driver) return result
def test_vqe_mes(self): """ Test VQEUCCSDFactory with QEOM """ solver = VQEUCCFactory(self.quantum_instance) gsc = GroundStateEigensolver(self.qubit_converter, solver) esc = QEOM(gsc, 'sd') results = esc.solve(self.electronic_structure_problem) for idx in range(len(self.reference_energies)): self.assertAlmostEqual(results.computed_energies[idx], self.reference_energies[idx], places=4)
def test_numpy_mes(self): """ Test NumPyMinimumEigenSolver with QEOM """ solver = NumPyMinimumEigensolver() gsc = GroundStateEigensolver(self.qubit_converter, solver) esc = QEOM(gsc, 'sd') results = esc.solve(self.electronic_structure_problem) for idx in range(len(self.reference_energies)): self.assertAlmostEqual(results.computed_energies[idx], self.reference_energies[idx], places=4)
def test_vqe_mes(self): """ Test VQEUCCSDFactory with QEOM """ solver = VQEUCCSDFactory(self.quantum_instance) gsc = GroundStateEigensolver(self.transformation, solver) esc = QEOM(gsc, 'sd') results = esc.solve(self.driver) for idx in range(len(self.reference_energies)): self.assertAlmostEqual(results.computed_energies[idx], self.reference_energies[idx], places=4)
def test_numpy_mes(self): """ Test NumPyMinimumEigenSolver with QEOM """ solver = NumPyMinimumEigensolver() gsc = GroundStateEigensolver(self.transformation, solver) esc = QEOM(gsc, 'sd') results = esc.solve(self.driver) for idx in range(len(self.reference_energies)): self.assertAlmostEqual(results.computed_energies[idx], self.reference_energies[idx], places=4)
def test_numpy_mes(self): """ Test with NumPyMinimumEigensolver """ solver = NumPyMinimumEigensolverFactory(use_default_filter_criterion=True) gsc = GroundStateEigensolver(self.qubit_converter, solver) esc = QEOM(gsc, 'sd') results = esc.solve(self.vibrational_problem) for idx in range(len(self.reference_energies)): self.assertAlmostEqual(results.computed_vibrational_energies[idx], self.reference_energies[idx], places=4)
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_vqe_uvccsd_factory(self): """ Test with VQE plus UVCCSD """ optimizer = COBYLA(maxiter=5000) solver = VQEUVCCFactory(QuantumInstance(BasicAer.get_backend('statevector_simulator')), optimizer=optimizer) gsc = GroundStateEigensolver(self.qubit_converter, solver) esc = QEOM(gsc, 'sd') results = esc.solve(self.vibrational_problem) for idx in range(len(self.reference_energies)): self.assertAlmostEqual(results.computed_vibrational_energies[idx], self.reference_energies[idx], places=1)
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 optimizer = SPSA(maxiter=200, last_avg=5) solver = VQE(var_form=self.var_form, optimizer=optimizer, expectation=PauliExpectation(), quantum_instance=QuantumInstance( backend=backend, seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed)) gsc = GroundStateEigensolver(self.fermionic_transformation, solver) result = gsc.solve(self.driver) self.assertAlmostEqual(result.total_energies[0], -1.138, places=2)
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)