def test_vqe_adapt(self): """ VQEAdapt test """ try: # pylint: disable=import-outside-toplevel from qiskit import Aer except Exception as ex: # pylint: disable=broad-except self.skipTest( "Aer doesn't appear to be installed. Error: '{}'".format( str(ex))) return self.var_form_base = UCCSD(self.num_qubits, 1, self.num_spin_orbitals, self.num_particles, initial_state=self.init_state) backend = Aer.get_backend('statevector_simulator') optimizer = L_BFGS_B() algorithm = VQEAdapt(self.qubit_op, self.var_form_base, optimizer, threshold=0.00001, delta=0.1) result = algorithm.run(backend) self.assertAlmostEqual(result['energy'], -1.85727503, places=2) self.assertIn('num_iterations', result) self.assertIn('final_max_grad', result) self.assertIn('finishing_criterion', result)
def vqe_create_solver(num_particles, num_orbitals, qubit_mapping, two_qubit_reduction, z2_symmetries, initial_point = system.opt_amplitudes, noise = noise): 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) if noise: var_form = EfficientSU2(num_qubits = no_qubits, entanglement="linear") else: 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, optimizer=SLSQP(maxiter=500), include_custom=True, initial_point = initial_point) vqe.quantum_instance = backend return vqe
def generate_uccsd(molecule_data): molecule, qubitOp, map_type, num_particles, num_spin_orbitals = load_qubitop_for_molecule(molecule_data) nuclear_repulsion_energy = molecule.nuclear_repulsion_energy print("# of electrons: {}".format(num_particles)) print("# of spin orbitals: {}".format(num_spin_orbitals)) qubit_reduction = False HF_state = HartreeFock(num_spin_orbitals, num_particles, map_type, qubit_reduction) uccsd_ansatz = UCCSD(reps=1, num_orbitals=num_spin_orbitals, num_particles=num_particles, initial_state=HF_state, qubit_mapping=map_type, two_qubit_reduction=qubit_reduction) circ = uccsd_ansatz.construct_circuit([0.4242] * uccsd_ansatz.num_parameters) circ.measure_all() circ_transpiled = processor.transpile(circ) q_layer = qiskit2tq(circ_transpiled) for name, param in q_layer.named_parameters(): if not (param % (np.pi / 2)).detach().cpu().numpy().any(): param.requires_grad = False #randlist = np.random.rand(uccsd_ansatz.num_parameters) # ansatz parameters #uccsd_ansatz_circuit = uccsd_ansatz.construct_circuit(randlist) return q_layer
def test_uccsd_hf_excitations(self): """ uccsd tapering test using all double excitations """ # initial state init_state = HartreeFock( num_qubits=self.the_tapered_op.num_qubits, num_orbitals=self.core._molecule_info['num_orbitals'], qubit_mapping=self.core._qubit_mapping, two_qubit_reduction=self.core._two_qubit_reduction, num_particles=self.core._molecule_info['num_particles'], sq_list=self.the_tapered_op.z2_symmetries.sq_list) # check singlet excitations var_form = UCCSD( num_qubits=self.the_tapered_op.num_qubits, depth=1, num_orbitals=self.core._molecule_info['num_orbitals'], num_particles=self.core._molecule_info['num_particles'], active_occupied=None, active_unoccupied=None, initial_state=init_state, qubit_mapping=self.core._qubit_mapping, two_qubit_reduction=self.core._two_qubit_reduction, num_time_slices=1, z2_symmetries=self.the_tapered_op.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_qubits=self.the_tapered_op.num_qubits, depth=1, num_orbitals=self.core._molecule_info['num_orbitals'], num_particles=self.core._molecule_info['num_particles'], active_occupied=None, active_unoccupied=None, initial_state=init_state, qubit_mapping=self.core._qubit_mapping, two_qubit_reduction=self.core._two_qubit_reduction, num_time_slices=1, z2_symmetries=self.the_tapered_op.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 test_uccsd_adapt(self): """ UCCSD test for adaptive features """ self.var_form_base = UCCSD(self.num_spin_orbitals, self.num_particles, initial_state=self.init_state) self.var_form_base.manage_hopping_operators() # assert that the excitation pool exists self.assertIsNotNone(self.var_form_base.excitation_pool) # assert that the hopping ops list has been reset to be empty self.assertEqual(self.var_form_base._hopping_ops, [])
class TestVQEAdaptUCCSD(QiskitChemistryTestCase): """ Test Adaptive VQE with UCCSD""" def setUp(self): super().setUp() # np.random.seed(50) self.seed = 50 aqua_globals.random_seed = self.seed try: driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.735', unit=UnitsType.ANGSTROM, basis='sto3g') except QiskitChemistryError: self.skipTest('PYSCF driver does not appear to be installed') return molecule = 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 = Z2Symmetries.two_qubit_reduction(to_weighted_pauli_operator(qubit_op), self.num_particles) 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_adapt(self): """ UCCSD test for adaptive features """ self.var_form_base = UCCSD(self.num_spin_orbitals, self.num_particles, initial_state=self.init_state) self.var_form_base.manage_hopping_operators() # assert that the excitation pool exists self.assertIsNotNone(self.var_form_base.excitation_pool) # assert that the hopping ops list has been reset to be empty self.assertEqual(self.var_form_base._hopping_ops, []) def test_vqe_adapt(self): """ VQEAdapt test """ try: # pylint: disable=import-outside-toplevel from qiskit import Aer except Exception as ex: # pylint: disable=broad-except self.skipTest("Aer doesn't appear to be installed. Error: '{}'".format(str(ex))) return self.var_form_base = UCCSD(self.num_spin_orbitals, self.num_particles, initial_state=self.init_state) backend = Aer.get_backend('statevector_simulator') optimizer = L_BFGS_B() algorithm = VQEAdapt(self.qubit_op, self.var_form_base, optimizer, threshold=0.00001, delta=0.1) result = algorithm.run(backend) self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=2) self.assertIsNotNone(result.num_iterations) self.assertIsNotNone(result.final_max_gradient) self.assertIsNotNone(result.finishing_criterion)
class TestVQEAdaptUCCSD(QiskitAquaTestCase): """ Test Adaptive VQE with UCCSD""" def setUp(self): super().setUp() # np.random.seed(50) self.seed = 50 aqua_globals.random_seed = self.seed driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.735', unit=UnitsType.ANGSTROM, basis='sto3g') molecule = 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 = Z2Symmetries.two_qubit_reduction( to_weighted_pauli_operator(qubit_op), self.num_particles) self.num_qubits = self.qubit_op.num_qubits self.init_state = HartreeFock(self.num_qubits, self.num_spin_orbitals, self.num_particles) self.var_form_base = None def test_uccsd_adapt(self): """ UCCSD test for adaptive features """ self.var_form_base = UCCSD(self.num_qubits, 1, self.num_spin_orbitals, self.num_particles, initial_state=self.init_state) self.var_form_base.manage_hopping_operators() # assert that the excitation pool exists self.assertIsNotNone(self.var_form_base.excitation_pool) # assert that the hopping ops list has been reset to be empty self.assertEqual(self.var_form_base._hopping_ops, []) def test_vqe_adapt(self): """ VQEAdapt test """ self.var_form_base = UCCSD(self.num_qubits, 1, self.num_spin_orbitals, self.num_particles, initial_state=self.init_state) backend = Aer.get_backend('statevector_simulator') optimizer = L_BFGS_B() algorithm = VQEAdapt(self.qubit_op, self.var_form_base, optimizer, threshold=0.00001, delta=0.1) result = algorithm.run(backend) self.assertAlmostEqual(result['energy'], -1.85727503, places=2) self.assertIn('num_iterations', result) self.assertIn('final_max_grad', result) self.assertIn('finishing_criterion', result)
def test_tapered_op(self): """ tapered op test """ optimizer = SLSQP(maxiter=1000) 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.z2_symmetries.sq_list) 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.z2_symmetries) 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, places=6)
def test_uccsd_hf_qpUCCD(self): """ paired uccd test """ optimizer = SLSQP(maxiter=100) initial_state = HartreeFock(self.qubit_op.num_qubits, self.core.molecule_info['num_orbitals'], self.core.molecule_info['num_particles'], qubit_mapping=self.core._qubit_mapping, two_qubit_reduction=self.core._two_qubit_reduction) var_form = UCCSD(num_qubits=self.qubit_op.num_qubits, depth=1, num_orbitals=self.core._molecule_info['num_orbitals'], num_particles=self.core._molecule_info['num_particles'], active_occupied=None, active_unoccupied=None, initial_state=initial_state, qubit_mapping=self.core._qubit_mapping, two_qubit_reduction=self.core._two_qubit_reduction, num_time_slices=1, shallow_circuit_concat=False, method_doubles='pucc', excitation_type='d' ) algo = VQE(self.qubit_op, var_form, optimizer) result = algo.run(QuantumInstance(BasicAer.get_backend('statevector_simulator'))) _, result = self.core.process_algorithm_result(result) self.assertAlmostEqual(result['energy'], self.reference_energy_pUCCD, places=6)
def test_tapered_op(self): """ tapered op test """ tapered_ops = self.z2_symmetries.taper(self.qubit_op) smallest_idx = 0 # Prior knowledge of which tapered_op has ground state the_tapered_op = tapered_ops[smallest_idx] optimizer = SLSQP(maxiter=1000) init_state = HartreeFock(num_qubits=the_tapered_op.num_qubits, num_orbitals=self.core._molecule_info['num_orbitals'], qubit_mapping=self.core._qubit_mapping, two_qubit_reduction=self.core._two_qubit_reduction, num_particles=self.core._molecule_info['num_particles'], sq_list=the_tapered_op.z2_symmetries.sq_list) var_form = UCCSD(num_qubits=the_tapered_op.num_qubits, depth=1, num_orbitals=self.core._molecule_info['num_orbitals'], num_particles=self.core._molecule_info['num_particles'], active_occupied=None, active_unoccupied=None, initial_state=init_state, qubit_mapping=self.core._qubit_mapping, two_qubit_reduction=self.core._two_qubit_reduction, num_time_slices=1, z2_symmetries=the_tapered_op.z2_symmetries) algo = VQE(the_tapered_op, var_form, optimizer) backend = BasicAer.get_backend('statevector_simulator') quantum_instance = QuantumInstance(backend=backend) algo_result = algo.run(quantum_instance) _, result = self.core.process_algorithm_result(algo_result) self.assertAlmostEqual(result['energy'], self.reference_energy, places=6)
def test_uccsd_hf(self): """ uccsd hf test """ driver = HDF5Driver(self.get_resource_path('test_driver_hdf5.hdf5')) qmolecule = driver.run() core = Hamiltonian(qubit_mapping=QubitMappingType.PARITY, two_qubit_reduction=True) qubit_op, _ = core.run(qmolecule) optimizer = SLSQP(maxiter=100) initial_state = HartreeFock( core.molecule_info['num_orbitals'], core.molecule_info['num_particles'], qubit_mapping=core._qubit_mapping, two_qubit_reduction=core._two_qubit_reduction) var_form = UCCSD(num_orbitals=core.molecule_info['num_orbitals'], num_particles=core.molecule_info['num_particles'], initial_state=initial_state, qubit_mapping=core._qubit_mapping, two_qubit_reduction=core._two_qubit_reduction) algo = VQE(qubit_op, var_form, optimizer) result = algo.run( QuantumInstance(BasicAer.get_backend('statevector_simulator'))) result = core.process_algorithm_result(result) self.assertAlmostEqual(result.energy, self.reference_energy, places=6)
def test_h2_two_qubits_statevector(self): """Test H2 with parity mapping and statevector backend.""" two_qubit_reduction = True qubit_mapping = 'parity' core = Hamiltonian(transformation=TransformationType.FULL, qubit_mapping=QubitMappingType.PARITY, two_qubit_reduction=two_qubit_reduction, freeze_core=False, orbital_reduction=[]) qubit_op, _ = core.run(self.molecule) num_orbitals = core.molecule_info['num_orbitals'] num_particles = core.molecule_info['num_particles'] initial_state = HartreeFock(qubit_op.num_qubits, num_orbitals=num_orbitals, num_particles=num_particles, qubit_mapping=qubit_mapping, two_qubit_reduction=two_qubit_reduction) var_form = UCCSD(num_qubits=qubit_op.num_qubits, depth=1, num_orbitals=num_orbitals, num_particles=num_particles, initial_state=initial_state, qubit_mapping=qubit_mapping, two_qubit_reduction=two_qubit_reduction) optimizer = COBYLA(maxiter=1000, tol=1e-8) eom_vqe = QEomVQE(qubit_op, var_form, optimizer, num_orbitals=num_orbitals, num_particles=num_particles, qubit_mapping=qubit_mapping, two_qubit_reduction=two_qubit_reduction) backend = BasicAer.get_backend('statevector_simulator') quantum_instance = QuantumInstance(backend) result = eom_vqe.run(quantum_instance) np.testing.assert_array_almost_equal(self.reference, result['energies'], decimal=4)
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 setUp(self): super().setUp() self.reference_energy = -1.1373060356951838 self.seed = 700 aqua_globals.random_seed = self.seed self.driver = HDF5Driver( self.get_resource_path('test_driver_hdf5.hdf5')) fermionic_transformation = FermionicTransformation( qubit_mapping=QubitMappingType.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 test_vqe_auto_symmetry_freeze_core(self): """ Auto symmetry reduction, with freeze core using VQE """ core = Hamiltonian(transformation=TransformationType.FULL, qubit_mapping=QubitMappingType.JORDAN_WIGNER, two_qubit_reduction=False, freeze_core=True, orbital_reduction=None, z2symmetry_reduction='auto') qubit_op, aux_ops = core.run(self.qmolecule) self.assertEqual(qubit_op.num_qubits, 6) num_orbitals = core.molecule_info[core.INFO_NUM_ORBITALS] num_particles = core.molecule_info[core.INFO_NUM_PARTICLES] qubit_mapping = 'jordan_wigner' two_qubit_reduction = core.molecule_info[core.INFO_TWO_QUBIT_REDUCTION] z2_symmetries = core.molecule_info[core.INFO_Z2SYMMETRIES] 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(qubit_op, var_form=var_form, optimizer=SLSQP(maxiter=500), aux_operators=aux_ops) vqe.quantum_instance = BasicAer.get_backend('statevector_simulator') result = core.process_algorithm_result(vqe.compute_minimum_eigenvalue()) self._validate_result(result) self.assertEqual(core.molecule_info[core.INFO_Z2SYMMETRIES].tapering_values, [-1, 1, 1, -1])
def test_uccsd_hf_qUCCSD(self): """ uccsd tapering test using all double excitations """ # optimizer optimizer = SLSQP(maxiter=100) # initial state init_state = HartreeFock(num_qubits=self.the_tapered_op.num_qubits, num_orbitals=self.core._molecule_info['num_orbitals'], qubit_mapping=self.core._qubit_mapping, two_qubit_reduction=self.core._two_qubit_reduction, num_particles=self.core._molecule_info['num_particles'], sq_list=self.the_tapered_op.z2_symmetries.sq_list) var_form = UCCSD(num_qubits=self.the_tapered_op.num_qubits, depth=1, num_orbitals=self.core._molecule_info['num_orbitals'], num_particles=self.core._molecule_info['num_particles'], active_occupied=None, active_unoccupied=None, initial_state=init_state, qubit_mapping=self.core._qubit_mapping, two_qubit_reduction=self.core._two_qubit_reduction, num_time_slices=1, z2_symmetries=self.the_tapered_op.z2_symmetries, shallow_circuit_concat=False, method_doubles='ucc', excitation_type='sd', skip_commute_test=True) algo = VQE(self.the_tapered_op, var_form, optimizer) result = algo.run(QuantumInstance(BasicAer.get_backend('statevector_simulator'))) _, result = self.core.process_algorithm_result(result) self.assertAlmostEqual(result['energy'], self.reference_energy_UCCSD, places=6)
def _compute_mp2(qmolecule, threshold): terms = {} mp2_delta = 0 num_orbitals = qmolecule.num_orbitals ints = qmolecule.mo_eri_ints o_e = qmolecule.orbital_energies # Orbital indexes given by this method are numbered according to the blocked spin ordering _, doubles = UCCSD.compute_excitation_lists([qmolecule.num_alpha, qmolecule.num_beta], num_orbitals * 2, same_spin_doubles=True) # doubles is list of [from, to, from, to] in spin orbital indexing where alpha runs # from 0 to num_orbitals-1, and beta from num_orbitals to num_orbitals*2-1 for n, _ in enumerate(doubles): idxs = doubles[n] i = idxs[0] % num_orbitals # Since spins are same drop to MO indexing j = idxs[2] % num_orbitals a_i = idxs[1] % num_orbitals b = idxs[3] % num_orbitals tiajb = ints[i, a_i, j, b] tibja = ints[i, b, j, a_i] num = (2 * tiajb - tibja) denom = o_e[b] + o_e[a_i] - o_e[i] - o_e[j] coeff = -num / denom coeff = coeff if abs(coeff) > threshold else 0 e_delta = coeff * tiajb e_delta = e_delta if abs(e_delta) > threshold else 0 terms[_list_to_str(idxs)] = (coeff, e_delta) mp2_delta += e_delta return terms, mp2_delta
def setUp(self): super().setUp() self.reference_energy = -1.1373060356951838 self.seed = 700 aqua_globals.random_seed = self.seed driver = HDF5Driver(self.get_resource_path('test_driver_hdf5.hdf5')) qmolecule = driver.run() core = Hamiltonian(qubit_mapping=QubitMappingType.PARITY, two_qubit_reduction=True) self.qubit_op, _ = core.run(qmolecule) self.core = core self.optimizer = SLSQP(maxiter=100) initial_state = HartreeFock( core.molecule_info['num_orbitals'], core.molecule_info['num_particles'], qubit_mapping=core._qubit_mapping, two_qubit_reduction=core._two_qubit_reduction) self.var_form = UCCSD( num_orbitals=core.molecule_info['num_orbitals'], num_particles=core.molecule_info['num_particles'], initial_state=initial_state, qubit_mapping=core._qubit_mapping, two_qubit_reduction=core._two_qubit_reduction)
def build_hopping_operators(self, excitations: Union[str, List[List[int]]] = 'sd' ) -> Tuple[Dict[str, WeightedPauliOperator], Dict[str, List[bool]], Dict[str, List[Any]]]: """Builds the product of raising and lowering operators (basic excitation operators) Args: excitations: The excitations to be included in the eom pseudo-eigenvalue problem. If a string ('s', 'd' or 'sd') then all excitations of the given type will be used. Otherwise a list of custom excitations can directly be provided. Returns: A tuple containing the hopping operators, the types of commutativities and the excitation indices. """ num_alpha, num_beta = self._molecule_info['num_particles'] num_orbitals = self._molecule_info['num_orbitals'] if isinstance(excitations, str): se_list, de_list = UCCSD.compute_excitation_lists([num_alpha, num_beta], num_orbitals, excitation_type=excitations) excitations_list = se_list+de_list else: excitations_list = excitations size = len(excitations_list) # # get all to-be-processed index # mus, nus = np.triu_indices(size) # build all hopping operators hopping_operators: Dict[str, WeightedPauliOperator] = {} type_of_commutativities: Dict[str, List[bool]] = {} excitation_indices = {} to_be_executed_list = [] for idx in range(size): to_be_executed_list += [excitations_list[idx], list(reversed(excitations_list[idx]))] hopping_operators['E_{}'.format(idx)] = None hopping_operators['Edag_{}'.format(idx)] = None type_of_commutativities['E_{}'.format(idx)] = None type_of_commutativities['Edag_{}'.format(idx)] = None excitation_indices['E_{}'.format(idx)] = excitations_list[idx] excitation_indices['Edag_{}'.format(idx)] = list(reversed(excitations_list[idx])) result = parallel_map(self._build_single_hopping_operator, to_be_executed_list, task_args=(num_alpha + num_beta, num_orbitals, self._qubit_mapping, self._two_qubit_reduction, self._molecule_info['z2_symmetries']), num_processes=aqua_globals.num_processes) for key, res in zip(hopping_operators.keys(), result): hopping_operators[key] = res[0] type_of_commutativities[key] = res[1] return hopping_operators, type_of_commutativities, excitation_indices
def test_uccsd_hf_qUCCSD(self): """ uccsd tapering test using all double excitations """ fermionic_transformation = FermionicTransformation( transformation=TransformationType.FULL, qubit_mapping=QubitMappingType.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.energy, self.reference_energy_UCCSD, places=6)
def test_vqe_adapt(self): """ VQEAdapt test """ self.var_form_base = UCCSD(self.num_qubits, 1, self.num_spin_orbitals, self.num_particles, initial_state=self.init_state) backend = Aer.get_backend('statevector_simulator') optimizer = L_BFGS_B() algorithm = VQEAdapt(self.qubit_op, self.var_form_base, optimizer, threshold=0.00001, delta=0.1) result = algorithm.run(backend) self.assertAlmostEqual(result['energy'], -1.85727503, places=2) self.assertIn('num_iterations', result) self.assertIn('final_max_grad', result) self.assertIn('finishing_criterion', result)
def __init__(self, operator, num_orbitals, num_particles, qubit_mapping=None, two_qubit_reduction=False, active_occupied=None, active_unoccupied=None, is_eom_matrix_symmetric=True, se_list=None, de_list=None, z2_symmetries=None, untapered_op=None): """Constructor. Args: operator (WeightedPauliOperator): qubit operator num_orbitals (int): total number of spin orbitals num_particles (Union(list, int)): number of particles, if it is a list, the first number is alpha and the second number if beta. qubit_mapping (str): qubit mapping type two_qubit_reduction (bool): two qubit reduction is applied or not active_occupied (list): list of occupied orbitals to include, indices are 0 to n where n is num particles // 2 active_unoccupied (list): list of unoccupied orbitals to include, indices are 0 to m where m is (num_orbitals - num particles) // 2 is_eom_matrix_symmetric (bool): is EoM matrix symmetric se_list (list[list]): single excitation list, overwrite the setting in active space de_list (list[list]): double excitation list, overwrite the setting in active space z2_symmetries (Z2Symmetries): represent the Z2 symmetries untapered_op (WeightedPauliOperator): if the operator is tapered, we need untapered operator to build element of EoM matrix """ self._operator = operator self._num_orbitals = num_orbitals self._num_particles = num_particles self._qubit_mapping = qubit_mapping self._two_qubit_reduction = two_qubit_reduction self._active_occupied = active_occupied self._active_unoccupied = active_unoccupied se_list_default, de_list_default = UCCSD.compute_excitation_lists( self._num_particles, self._num_orbitals, self._active_occupied, self._active_unoccupied) if se_list is None: self._se_list = se_list_default else: self._se_list = se_list logger.info("Use user-specified single excitation list: %s", self._se_list) if de_list is None: self._de_list = de_list_default else: self._de_list = de_list logger.info("Use user-specified double excitation list: %s", self._de_list) self._z2_symmetries = z2_symmetries if z2_symmetries is not None \ else Z2Symmetries([], [], []) self._untapered_op = untapered_op if untapered_op is not None else operator self._is_eom_matrix_symmetric = is_eom_matrix_symmetric
def test_vqe_adapt(self): """ VQEAdapt test """ 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 self.var_form_base = UCCSD(self.num_spin_orbitals, self.num_particles, initial_state=self.init_state) optimizer = L_BFGS_B() warnings.filterwarnings('ignore', category=DeprecationWarning) algorithm = VQEAdapt(self.qubit_op, self.var_form_base, optimizer, threshold=0.00001, delta=0.1, max_iterations=1) warnings.filterwarnings('always', category=DeprecationWarning) result = algorithm.run(backend) self.assertEqual(result.num_iterations, 1) self.assertEqual(result.finishing_criterion, 'Maximum number of iterations reached') warnings.filterwarnings('ignore', category=DeprecationWarning) algorithm = VQEAdapt(self.qubit_op, self.var_form_base, optimizer, threshold=0.00001, delta=0.1) warnings.filterwarnings('always', category=DeprecationWarning) result = algorithm.run(backend) self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=2) self.assertEqual(result.num_iterations, 2) self.assertAlmostEqual(result.final_max_gradient, 0.0, places=5) self.assertEqual(result.finishing_criterion, 'Threshold converged')
def cb_create_solver(num_particles, num_orbitals, qubit_mapping, two_qubit_reduction, 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, optimizer=SLSQP(maxiter=500)) vqe.quantum_instance = BasicAer.get_backend('statevector_simulator') return vqe
def _build(self): # wipe current state self._data = [] self.qregs = [] self._qubits = [] self._parameter_table = ParameterTable() print(self.parameters) # get UCCSD circuit uccsd = UCCSDVarForm(self._num_orbitals, self._num_particles, self.reps) params = ParameterVector('th', uccsd.num_parameters) circuit = uccsd.construct_circuit(params) # transpile to a basis gate set we can handle in the gradient calculation transpiled = transpile(circuit, basis_gates=['sx', 'rz', 'cx']) # add to self and store the parametervector for assigning self._params = params qreg = QuantumRegister(uccsd.num_qubits) self.add_register(qreg) self.compose(transpiled, inplace=True)
def calculate_ground_energy(target_molecule): qubitOp, num_particles, num_spin_orbitals, shift = get_qubit_op( target_molecule) initial_state = HartreeFock(num_spin_orbitals, num_particles, qubit_mapping='parity') var_form = UCCSD(num_orbitals=num_spin_orbitals, num_particles=num_particles, initial_state=initial_state, qubit_mapping='parity') vqe = VQE(qubitOp, var_form, optimizer) vqe_result = np.real(vqe.run(backend)['eigenvalue'] + shift) return vqe_result
def test_h2_one_qubit_statevector(self): """Test H2 with tapering and statevector backend.""" two_qubit_reduction = True qubit_mapping = 'parity' core = Hamiltonian(transformation=TransformationType.FULL, qubit_mapping=QubitMappingType.PARITY, two_qubit_reduction=two_qubit_reduction, freeze_core=False, orbital_reduction=[]) qubit_op, _ = core.run(self.molecule) num_orbitals = core.molecule_info['num_orbitals'] num_particles = core.molecule_info['num_particles'] # tapering z2_symmetries = Z2Symmetries.find_Z2_symmetries(qubit_op) # know the sector tapered_op = z2_symmetries.taper(qubit_op)[1] initial_state = HartreeFock(tapered_op.num_qubits, num_orbitals=num_orbitals, num_particles=num_particles, qubit_mapping=qubit_mapping, two_qubit_reduction=two_qubit_reduction, sq_list=tapered_op.z2_symmetries.sq_list) var_form = UCCSD(num_qubits=tapered_op.num_qubits, depth=1, num_orbitals=num_orbitals, num_particles=num_particles, initial_state=initial_state, qubit_mapping=qubit_mapping, two_qubit_reduction=two_qubit_reduction, z2_symmetries=tapered_op.z2_symmetries) optimizer = SPSA(max_trials=50) eom_vqe = QEomVQE(tapered_op, var_form, optimizer, num_orbitals=num_orbitals, num_particles=num_particles, qubit_mapping=qubit_mapping, two_qubit_reduction=two_qubit_reduction, z2_symmetries=tapered_op.z2_symmetries, untapered_op=qubit_op) backend = BasicAer.get_backend('statevector_simulator') quantum_instance = QuantumInstance(backend) result = eom_vqe.run(quantum_instance) np.testing.assert_array_almost_equal(self.reference, result['energies'], decimal=5)
def cb_default_solver(num_particles, num_orbitals, qubit_mapping, two_qubit_reduction, z2_symmetries): """ Default solver """ 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) vqe.quantum_instance = quantum_instance return vqe
def print_UCCSD_parameters(molecule, core, var_form, algo_result, z2syms, sqlist, deleted_orbitals, outfile): sd, dd = UCCSD.compute_excitation_lists( [var_form._num_alpha, var_form._num_beta], var_form._num_orbitals, None, None, same_spin_doubles=var_form.same_spin_doubles, method_singles=var_form._method_singles, method_doubles=var_form._method_doubles, excitation_type=var_form._excitation_type) kept_orbitals = [ x for x in range(molecule.num_orbitals) if x not in deleted_orbitals ] ed = sd + dd results = parallel_map(UCCSD._build_hopping_operator, ed, task_args=(var_form._num_orbitals, [ var_form._num_alpha, var_form._num_beta ], core._qubit_mapping, core._two_qubit_reduction, z2syms), num_processes=aqua_globals.num_processes) def convert_index(idx): idx_converted = [] for i in idx: if (i < len(kept_orbitals)): idx_converted.append(str(kept_orbitals[i]) + 'u') else: idx_converted.append( str(kept_orbitals[i - len(kept_orbitals)]) + 'd') return idx_converted t = PrettyTable(['excitation', 'amplitude']) lst = [] im = 0 for m, (op, index) in enumerate(results): if op is not None and not op.is_empty(): lst.append( [convert_index(index), algo_result['optimal_point'][im]]) im += 1 for i in range(len(lst)): for j in range(i + 1, len(lst)): if (np.abs(lst[j][1]) > np.abs(lst[i][1])): lst[i], lst[j] = lst[j], lst[i] t.add_row([str(lst[i][0])] + [str(lst[i][1])]) outfile.write(str(t)) outfile.write("\n")
def init_var_form(self): if self.ansatz.upper() == 'UCCSD': # UCCSD Ansatz self.var_form = UCCSD( num_orbitals=self.core._molecule_info['num_orbitals'], num_particles=self.core._molecule_info['num_particles'], initial_state=self.init_state, qubit_mapping=self.core._qubit_mapping, two_qubit_reduction=self.core._two_qubit_reduction, num_time_slices=self.num_time_slices, excitation_type=self.excitation_type, shallow_circuit_concat=self.shallow_circuit_concat) else: if self.var_form is None: raise ValueError('No variational form specified!')