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_print_result(self): """Regression test against #198 and general issues with printing results.""" solver = NumPyMinimumEigensolverFactory() calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) with contextlib.redirect_stdout(io.StringIO()) as out: print(res) # do NOT change the below! Lines have been truncated as to not force exact numerical matches expected = """\ === GROUND STATE ENERGY === * Electronic ground state energy (Hartree): -1.857 - computed part: -1.857 ~ Nuclear repulsion energy (Hartree): 0.719 > Total ground state energy (Hartree): -1.137 === MEASURED OBSERVABLES === 0: # Particles: 2.000 S: 0.000 S^2: 0.000 M: 0.000 === DIPOLE MOMENTS === ~ Nuclear dipole moment (a.u.): [0.0 0.0 1.38 0: * Electronic dipole moment (a.u.): [0.0 0.0 -1.38 - computed part: [0.0 0.0 -1.38 > Dipole moment (a.u.): [0.0 0.0 0.0] Total: 0. (debye): [0.0 0.0 0.0] Total: 0. """ for truth, expected in zip(out.getvalue().split("\n"), expected.split("\n")): assert truth.strip().startswith(expected.strip())
def test_eval_op_qasm_aer(self): """Regression tests against https://github.com/Qiskit/qiskit-nature/issues/53.""" backend = qiskit.providers.aer.Aer.get_backend("aer_simulator") 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() 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_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(quantum_instance=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 test_total_dipole(self): """Regression test against #198. An issue with calculating the dipole moment that had division None/float. """ solver = NumPyMinimumEigensolverFactory() calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) self.assertAlmostEqual(res.total_dipole_moment_in_debye[0], 0.0, places=1)
def _setup_evaluation_operators(self): # first we run a ground state calculation solver = VQEUCCFactory(quantum_instance=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 _, second_q_ops = self.electronic_structure_problem.second_q_ops() aux_ops_dict = self.qubit_converter.convert_match(second_q_ops) return calc, res, aux_ops_dict
def test_default_initial_point(self): """Test when using the default initial point.""" solver = VQEUCCFactory(quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator"))) calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) np.testing.assert_array_equal(solver.initial_point.to_numpy_array(), [0.0, 0.0, 0.0]) self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6)
def _run_driver( driver: ElectronicStructureDriver, 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_vqe_ucc_factory_with_user_initial_point(self): """Test VQEUCCFactory when using it with a user defined initial point.""" initial_point = np.asarray( [1.28074029e-19, 5.92226076e-08, 1.11762559e-01]) solver = VQEUCCFactory( quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator")), initial_point=initial_point, optimizer=SLSQP(maxiter=1), ) calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) np.testing.assert_array_almost_equal(res.raw_result.optimal_point, initial_point)
def test_vqe_uvccsd_with_callback(self): """Test VQE UVCCSD with callback.""" def cb_callback(nfev, parameters, energy, stddev): print(f"iterations {nfev}: energy: {energy}") optimizer = COBYLA(maxiter=5000) quantum_instance = QuantumInstance( backend=qiskit.BasicAer.get_backend("statevector_simulator"), seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed, ) solver = VQEUVCCFactory(quantum_instance=quantum_instance, optimizer=optimizer, callback=cb_callback) gsc = GroundStateEigensolver(self.qubit_converter, solver) esc = QEOM(gsc, "sd") with contextlib.redirect_stdout(io.StringIO()) as out: results = esc.solve(self.vibrational_problem) for idx, energy in enumerate(self.reference_energies): self.assertAlmostEqual(results.computed_vibrational_energies[idx], energy, places=1) for idx, line in enumerate(out.getvalue().split("\n")): if line.strip(): self.assertTrue( line.startswith(f"iterations {idx+1}: energy: "))
def test_vqe_ucc_factory_with_mp2(self): """Test when using MP2InitialPoint to generate the initial point.""" informed_start = MP2InitialPoint() solver = VQEUCCFactory( quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator")), initial_point=informed_start, ) calc = GroundStateEigensolver(self.qubit_converter, solver) res = calc.solve(self.electronic_structure_problem) np.testing.assert_array_almost_equal( solver.initial_point.to_numpy_array(), [0.0, 0.0, -0.07197145]) self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6)
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 test_excitation_preserving(self): """Test the excitation preserving wavefunction on a chemistry example.""" driver = HDF5Driver( self.get_resource_path("test_driver_hdf5.hdf5", "second_q/drivers/hdf5d")) converter = QubitConverter(ParityMapper()) problem = ElectronicStructureProblem(driver) _ = problem.second_q_ops() particle_number = cast( ParticleNumber, problem.grouped_property_transformed.get_property(ParticleNumber)) num_particles = (particle_number.num_alpha, particle_number.num_beta) num_spin_orbitals = particle_number.num_spin_orbitals 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 _solve_with_vqe_mes(self, converter: QubitConverter): solver = VQEUCCFactory(quantum_instance=self.quantum_instance) gsc = GroundStateEigensolver(converter, solver) esc = QEOM(gsc, "sd") results = esc.solve(self.electronic_structure_problem) for idx, energy in enumerate(self.reference_energies): self.assertAlmostEqual(results.computed_energies[idx], energy, places=4)
def test_freeze_core_z2_symmetry_compatibility(self): """Regression test against #192. An issue arose when the FreezeCoreTransformer was combined with the automatic Z2Symmetry reduction. This regression test ensures that this behavior remains fixed. """ driver = HDF5Driver(hdf5_input=self.get_resource_path( "LiH_sto3g.hdf5", "second_q/transformers")) problem = ElectronicStructureProblem(driver, [FreezeCoreTransformer()]) qubit_converter = QubitConverter( ParityMapper(), two_qubit_reduction=True, z2symmetry_reduction="auto", ) solver = NumPyMinimumEigensolverFactory() gsc = GroundStateEigensolver(qubit_converter, solver) result = gsc.solve(problem) self.assertAlmostEqual(result.total_energies[0], -7.882, places=2)
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, energy in enumerate(self.reference_energies): self.assertAlmostEqual(results.computed_energies[idx], energy, places=4)
def test_vqe_uccsd_with_callback(self): """Test VQE UCCSD with callback.""" def callback(nfev, parameters, energy, stddev): # pylint: disable=unused-argument print(f"iterations {nfev}: energy: {energy}") solver = VQEUCCFactory( quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator")), callback=callback, ) calc = GroundStateEigensolver(self.qubit_converter, solver) with contextlib.redirect_stdout(io.StringIO()) as out: res = calc.solve(self.electronic_structure_problem) self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6) for idx, line in enumerate(out.getvalue().split("\n")): if line.strip(): self.assertTrue( line.startswith(f"iterations {idx+1}: energy: "))
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, energy in enumerate(self.reference_energies): self.assertAlmostEqual(results.computed_vibrational_energies[idx], energy, places=4)
def test_uccsd_hf_aer_qasm_snapshot(self): """uccsd hf test with Aer qasm simulator snapshot.""" backend = qiskit.providers.aer.Aer.get_backend("aer_simulator") 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_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 = list( ElectronicEnergy([ OneBodyElectronicIntegrals(ElectronicBasis.MO, (h_1, None)), TwoBodyElectronicIntegrals(ElectronicBasis.MO, (h_2, None, None, None)), ], ).second_q_ops().values()) 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_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_uccsd_hf_aer_qasm(self): """uccsd hf test with Aer qasm simulator.""" backend = qiskit.providers.aer.Aer.get_backend("aer_simulator") ansatz = self._prepare_uccsd_hf(self.qubit_converter) optimizer = SPSA(maxiter=200, last_avg=5) solver = VQE( ansatz=ansatz, optimizer=optimizer, expectation=PauliExpectation(group_paulis=False), quantum_instance=QuantumInstance( backend=backend, seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed, ), ) gsc = GroundStateEigensolver(self.qubit_converter, solver) result = gsc.solve(self.electronic_structure_problem) self.assertAlmostEqual(result.total_energies[0], -1.131, places=2)
def test_vqe_uvccsd_factory(self): """Test with VQE plus UVCCSD""" optimizer = COBYLA(maxiter=5000) quantum_instance = QuantumInstance( backend=qiskit.BasicAer.get_backend("statevector_simulator"), seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed, ) solver = VQEUVCCFactory(quantum_instance=quantum_instance, optimizer=optimizer) gsc = GroundStateEigensolver(self.qubit_converter, solver) esc = QEOM(gsc, "sd") results = esc.solve(self.vibrational_problem) for idx, energy in enumerate(self.reference_energies): self.assertAlmostEqual(results.computed_vibrational_energies[idx], energy, places=1)
def test_vqe_uvcc_factory_with_user_initial_point(self): """Test VQEUVCCFactory when using it with a user defined initial point.""" initial_point = np.asarray( [-7.35250290e-05, -9.73079292e-02, -5.43346282e-05]) optimizer = COBYLA(maxiter=1) quantum_instance = QuantumInstance( backend=qiskit.BasicAer.get_backend("statevector_simulator"), seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed, ) solver = VQEUVCCFactory(quantum_instance=quantum_instance, optimizer=optimizer, initial_point=initial_point) gsc = GroundStateEigensolver(self.qubit_converter, solver) esc = QEOM(gsc, "sd") results = esc.solve(self.vibrational_problem) np.testing.assert_array_almost_equal( results.raw_result.ground_state_raw_result.optimal_point, initial_point)