def solve( self, problem: BaseProblem, aux_operators: Optional[List[Union[SecondQuantizedOp, PauliSumOp]]] = None, ) -> EigenstateResult: """Compute Ground and Excited States properties. Args: problem: a class encoding a problem to be solved. aux_operators: Additional auxiliary operators to evaluate. Raises: NotImplementedError: If an operator in ``aux_operators`` is not of type ``FermionicOperator``. Returns: An interpreted :class:`~.EigenstateResult`. For more information see also :meth:`~.BaseProblem.interpret`. """ # get the operator and auxiliary operators, and transform the provided auxiliary operators # note that ``aux_operators`` contains not only the transformed ``aux_operators`` passed # by the user but also additional ones from the transformation second_q_ops = problem.second_q_ops() main_operator = self._qubit_converter.convert( second_q_ops[0], num_particles=problem.num_particles, sector_locator=problem.symmetry_sector_locator, ) aux_ops = self._qubit_converter.convert_match(second_q_ops[1:]) if aux_operators is not None: for aux_op in aux_operators: if isinstance(aux_op, SecondQuantizedOp): aux_ops.append( self._qubit_converter.convert_match(aux_op, True)) else: aux_ops.append(aux_op) if isinstance(self._solver, EigensolverFactory): # this must be called after transformation.transform solver = self._solver.get_solver(problem) else: solver = self._solver # if the eigensolver does not support auxiliary operators, reset them if not solver.supports_aux_operators(): aux_ops = None raw_es_result = solver.compute_eigenvalues(main_operator, aux_ops) eigenstate_result = EigenstateResult() eigenstate_result.raw_result = raw_es_result eigenstate_result.eigenenergies = raw_es_result.eigenvalues eigenstate_result.eigenstates = raw_es_result.eigenstates eigenstate_result.aux_operator_eigenvalues = raw_es_result.aux_operator_eigenvalues result = problem.interpret(eigenstate_result) return result
def solve( self, problem: BaseProblem, aux_operators: Optional[ListOrDictType[Union[SecondQuantizedOp, PauliSumOp]]] = None, ) -> EigenstateResult: """Compute Ground State properties. Args: problem: a class encoding a problem to be solved. aux_operators: Additional auxiliary operators to evaluate. Raises: ValueError: if the grouped property object returned by the driver does not contain a main property as requested by the problem being solved (`problem.main_property_name`) QiskitNatureError: if the user-provided `aux_operators` contain a name which clashes with an internally constructed auxiliary operator. Note: the names used for the internal auxiliary operators correspond to the `Property.name` attributes which generated the respective operators. Returns: An interpreted :class:`~.EigenstateResult`. For more information see also :meth:`~.BaseProblem.interpret`. """ main_operator, aux_ops = self.get_qubit_operators( problem, aux_operators) raw_mes_result = self._solver.compute_minimum_eigenvalue( main_operator, aux_ops) # type: ignore result = problem.interpret(raw_mes_result) return result
def build_hamiltonian( current_problem: BaseProblem) -> SecondQuantizedOp: """Returns the SecondQuantizedOp H(R) where H is the electronic hamiltonian and R is the current nuclear coordinates. This gives the electronic energies.""" hamiltonian_name = current_problem.main_property_name hamiltonian_op = current_problem.second_q_ops().get( hamiltonian_name, None) return hamiltonian_op
def get_qubit_operators( self, problem: BaseProblem, aux_operators: Optional[ListOrDictType[Union[SecondQuantizedOp, PauliSumOp]]] = None, ) -> Tuple[PauliSumOp, Optional[ListOrDictType[PauliSumOp]]]: """Gets the operator and auxiliary operators, and transforms the provided auxiliary operators""" # Note that ``aux_ops`` contains not only the transformed ``aux_operators`` passed by the # user but also additional ones from the transformation second_q_ops = problem.second_q_ops() aux_second_q_ops: ListOrDictType[SecondQuantizedOp] if isinstance(second_q_ops, list): main_second_q_op = second_q_ops[0] aux_second_q_ops = second_q_ops[1:] elif isinstance(second_q_ops, dict): name = problem.main_property_name main_second_q_op = second_q_ops.pop(name, None) if main_second_q_op is None: raise ValueError( f"The main `SecondQuantizedOp` associated with the {name} property cannot be " "`None`." ) aux_second_q_ops = second_q_ops main_operator = self._qubit_converter.convert( main_second_q_op, num_particles=problem.num_particles, sector_locator=problem.symmetry_sector_locator, ) aux_ops = self._qubit_converter.convert_match(aux_second_q_ops) if aux_operators is not None: wrapped_aux_operators: ListOrDict[Union[SecondQuantizedOp, PauliSumOp]] = ListOrDict( aux_operators ) for name_aux, aux_op in iter(wrapped_aux_operators): if isinstance(aux_op, SecondQuantizedOp): converted_aux_op = self._qubit_converter.convert_match(aux_op, True) else: converted_aux_op = aux_op if isinstance(aux_ops, list): aux_ops.append(converted_aux_op) elif isinstance(aux_ops, dict): if name_aux in aux_ops.keys(): raise QiskitNatureError( f"The key '{name_aux}' is already taken by an internally constructed " "auxiliary operator! Please use a different name for your custom " "operator." ) aux_ops[name_aux] = converted_aux_op if isinstance(self._solver, EigensolverFactory): # this must be called after transformation.transform self._solver = self._solver.get_solver(problem) # if the eigensolver does not support auxiliary operators, reset them if not self._solver.supports_aux_operators(): aux_ops = None return main_operator, aux_ops
def get_solver(self, problem: BaseProblem, qubit_converter: QubitConverter) -> MinimumEigensolver: """Returns a NumPyMinimumEigensolver which possibly uses the default filter criterion provided by the ``problem``. 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 NumPyMinimumEigensolver suitable to compute the ground state of the molecule. """ if not self.minimum_eigensolver.filter_criterion and self._use_default_filter_criterion: self._minimum_eigensolver.filter_criterion = problem.get_default_filter_criterion( ) return self._minimum_eigensolver
def solve( self, problem: BaseProblem, aux_operators: Optional[ListOrDictType[Union[SecondQuantizedOp, PauliSumOp]]] = None, ) -> EigenstateResult: """Compute Ground State properties. Args: problem: a class encoding a problem to be solved. aux_operators: Additional auxiliary operators to evaluate. Raises: ValueError: if the grouped property object returned by the driver does not contain a main property as requested by the problem being solved (`problem.main_property_name`) QiskitNatureError: if the user-provided `aux_operators` contain a name which clashes with an internally constructed auxiliary operator. Note: the names used for the internal auxiliary operators correspond to the `Property.name` attributes which generated the respective operators. Returns: An interpreted :class:`~.EigenstateResult`. For more information see also :meth:`~.BaseProblem.interpret`. """ # get the operator and auxiliary operators, and transform the provided auxiliary operators # note that ``aux_ops`` contains not only the transformed ``aux_operators`` passed by the # user but also additional ones from the transformation second_q_ops = problem.second_q_ops() aux_second_q_ops: ListOrDictType[SecondQuantizedOp] if isinstance(second_q_ops, list): main_second_q_op = second_q_ops[0] aux_second_q_ops = second_q_ops[1:] elif isinstance(second_q_ops, dict): name = problem.main_property_name main_second_q_op = second_q_ops.pop(name, None) if main_second_q_op is None: raise ValueError( f"The main `SecondQuantizedOp` associated with the {name} property cannot be " "`None`.") aux_second_q_ops = second_q_ops main_operator = self._qubit_converter.convert( main_second_q_op, num_particles=problem.num_particles, sector_locator=problem.symmetry_sector_locator, ) aux_ops = self._qubit_converter.convert_match(aux_second_q_ops) if aux_operators is not None: wrapped_aux_operators: ListOrDict[Union[ SecondQuantizedOp, PauliSumOp]] = ListOrDict(aux_operators) for name, aux_op in iter(wrapped_aux_operators): if isinstance(aux_op, SecondQuantizedOp): converted_aux_op = self._qubit_converter.convert_match( aux_op, True) else: converted_aux_op = aux_op if isinstance(aux_ops, list): aux_ops.append(converted_aux_op) elif isinstance(aux_ops, dict): if name in aux_ops.keys(): raise QiskitNatureError( f"The key '{name}' is already taken by an internally constructed " "auxliliary operator! Please use a different name for your custom " "operator.") aux_ops[name] = converted_aux_op if isinstance(self._solver, MinimumEigensolverFactory): # this must be called after transformation.transform self._solver = self._solver.get_solver(problem, self._qubit_converter) # if the eigensolver does not support auxiliary operators, reset them if not self._solver.supports_aux_operators(): aux_ops = None raw_mes_result = self._solver.compute_minimum_eigenvalue( main_operator, aux_ops) result = problem.interpret(raw_mes_result) return result
def solve( self, problem: BaseProblem, aux_operators: Optional[List[SecondQuantizedOp]] = None ) -> EigenstateResult: """Run the excited-states calculation. Construct and solves the EOM pseudo-eigenvalue problem to obtain the excitation energies and the excitation operators expansion coefficients. Args: problem: a class encoding a problem to be solved. aux_operators: Additional auxiliary operators to evaluate. Returns: An interpreted :class:`~.EigenstateResult`. For more information see also :meth:`~.BaseProblem.interpret`. """ if aux_operators is not None: logger.warning( "With qEOM the auxiliary operators can currently only be " "evaluated on the ground state.") # 1. Run ground state calculation groundstate_result = self._gsc.solve(problem) # 2. Prepare the excitation operators self._untapered_qubit_op_main = self._gsc._qubit_converter.map( problem.second_q_ops()[0]) matrix_operators_dict, size = self._prepare_matrix_operators(problem) # 3. Evaluate eom operators measurement_results = self._gsc.evaluate_operators( groundstate_result.eigenstates[0], matrix_operators_dict) measurement_results = cast(Dict[str, List[float]], measurement_results) # 4. Post-process ground_state_result to construct eom matrices m_mat, v_mat, q_mat, w_mat, m_mat_std, v_mat_std, q_mat_std, w_mat_std = \ self._build_eom_matrices(measurement_results, size) # 5. solve pseudo-eigenvalue problem energy_gaps, expansion_coefs = self._compute_excitation_energies( m_mat, v_mat, q_mat, w_mat) qeom_result = QEOMResult() qeom_result.ground_state_raw_result = groundstate_result.raw_result qeom_result.expansion_coefficients = expansion_coefs qeom_result.excitation_energies = energy_gaps qeom_result.m_matrix = m_mat qeom_result.v_matrix = v_mat qeom_result.q_matrix = q_mat qeom_result.w_matrix = w_mat qeom_result.m_matrix_std = m_mat_std qeom_result.v_matrix_std = v_mat_std qeom_result.q_matrix_std = q_mat_std qeom_result.w_matrix_std = w_mat_std eigenstate_result = EigenstateResult() eigenstate_result.eigenstates = groundstate_result.eigenstates eigenstate_result.aux_operator_eigenvalues = groundstate_result.aux_operator_eigenvalues eigenstate_result.raw_result = qeom_result eigenstate_result.eigenenergies = np.append( groundstate_result.eigenenergies, np.asarray([ groundstate_result.eigenenergies[0] + gap for gap in energy_gaps ])) result = problem.interpret(eigenstate_result) return result
def solve( self, problem: BaseProblem, aux_operators: Optional[List[Union[SecondQuantizedOp, PauliSumOp]]] = None, ) -> "AdaptVQEResult": """Computes the ground state. Args: problem: a class encoding a problem to be solved. aux_operators: Additional auxiliary operators to evaluate. Raises: QiskitNatureError: if a solver other than VQE or a ansatz other than UCCSD is provided or if the algorithm finishes due to an unforeseen reason. Returns: An AdaptVQEResult which is an ElectronicStructureResult but also includes runtime information about the AdaptVQE algorithm like the number of iterations, finishing criterion, and the final maximum gradient. """ second_q_ops = problem.second_q_ops() self._main_operator = self._qubit_converter.convert( second_q_ops[0], num_particles=problem.num_particles, sector_locator=problem.symmetry_sector_locator, ) aux_ops = self._qubit_converter.convert_match(second_q_ops[1:]) if aux_operators is not None: for aux_op in aux_operators: if isinstance(aux_op, SecondQuantizedOp): aux_ops.append( self._qubit_converter.convert_match(aux_op, True)) else: aux_ops.append(aux_op) if isinstance(self._solver, MinimumEigensolverFactory): vqe = self._solver.get_solver(problem, self._qubit_converter) else: vqe = self._solver if not isinstance(vqe, VQE): raise QiskitNatureError( "The AdaptVQE algorithm requires the use of the VQE solver") if not isinstance(vqe.ansatz, UCC): raise QiskitNatureError( "The AdaptVQE algorithm requires the use of the UCC ansatz") # We construct the ansatz once to be able to extract the full set of excitation operators. self._ansatz = copy.deepcopy(vqe.ansatz) self._ansatz._build() self._excitation_pool = copy.deepcopy(self._ansatz.operators) threshold_satisfied = False alternating_sequence = False max_iterations_exceeded = False prev_op_indices: List[int] = [] theta: List[float] = [] max_grad: Tuple[float, Optional[PauliSumOp]] = (0.0, None) iteration = 0 while self._max_iterations is None or iteration < self._max_iterations: iteration += 1 logger.info("--- Iteration #%s ---", str(iteration)) # compute gradients cur_grads = self._compute_gradients(theta, vqe) # pick maximum gradient max_grad_index, max_grad = max(enumerate(cur_grads), key=lambda item: np.abs(item[1][0])) # store maximum gradient's index for cycle detection prev_op_indices.append(max_grad_index) # log gradients if logger.isEnabledFor(logging.INFO): gradlog = "\nGradients in iteration #{}".format(str(iteration)) gradlog += "\nID: Excitation Operator: Gradient <(*) maximum>" for i, grad in enumerate(cur_grads): gradlog += "\n{}: {}: {}".format(str(i), str(grad[1]), str(grad[0])) if grad[1] == max_grad[1]: gradlog += "\t(*)" logger.info(gradlog) if np.abs(max_grad[0]) < self._threshold: logger.info( "Adaptive VQE terminated successfully with a final maximum gradient: %s", str(np.abs(max_grad[0])), ) threshold_satisfied = True break # check indices of picked gradients for cycles if self._check_cyclicity(prev_op_indices): logger.info("Alternating sequence found. Finishing.") logger.info("Final maximum gradient: %s", str(np.abs(max_grad[0]))) alternating_sequence = True break # add new excitation to self._ansatz self._excitation_list.append(max_grad[1]) theta.append(0.0) # run VQE on current Ansatz self._ansatz.operators = self._excitation_list vqe.ansatz = self._ansatz vqe.initial_point = theta raw_vqe_result = vqe.compute_minimum_eigenvalue( self._main_operator) theta = raw_vqe_result.optimal_point.tolist() else: # reached maximum number of iterations max_iterations_exceeded = True logger.info("Maximum number of iterations reached. Finishing.") logger.info("Final maximum gradient: %s", str(np.abs(max_grad[0]))) # once finished evaluate auxiliary operators if any if aux_ops is not None: aux_values = self.evaluate_operators(raw_vqe_result.eigenstate, aux_ops) else: aux_values = None raw_vqe_result.aux_operator_eigenvalues = aux_values if threshold_satisfied: finishing_criterion = "Threshold converged" elif alternating_sequence: finishing_criterion = "Aborted due to cyclicity" elif max_iterations_exceeded: finishing_criterion = "Maximum number of iterations reached" else: raise QiskitNatureError( "The algorithm finished due to an unforeseen reason!") electronic_result = problem.interpret(raw_vqe_result) result = AdaptVQEResult() result.combine(electronic_result) result.num_iterations = iteration result.final_max_gradient = max_grad[0] result.finishing_criterion = finishing_criterion logger.info("The final energy is: %s", str(result.computed_energies[0])) return result
def solve( self, problem: BaseProblem, aux_operators: Optional[ListOrDictType[Union[SecondQuantizedOp, PauliSumOp]]] = None, ) -> "AdaptVQEResult": """Computes the ground state. Args: problem: a class encoding a problem to be solved. aux_operators: Additional auxiliary operators to evaluate. Raises: QiskitNatureError: if a solver other than VQE or a ansatz other than UCCSD is provided or if the algorithm finishes due to an unforeseen reason. ValueError: if the grouped property object returned by the driver does not contain a main property as requested by the problem being solved (`problem.main_property_name`) QiskitNatureError: if the user-provided `aux_operators` contain a name which clashes with an internally constructed auxiliary operator. Note: the names used for the internal auxiliary operators correspond to the `Property.name` attributes which generated the respective operators. Returns: An AdaptVQEResult which is an ElectronicStructureResult but also includes runtime information about the AdaptVQE algorithm like the number of iterations, finishing criterion, and the final maximum gradient. """ second_q_ops = problem.second_q_ops() aux_second_q_ops: ListOrDictType[SecondQuantizedOp] if isinstance(second_q_ops, list): main_second_q_op = second_q_ops[0] aux_second_q_ops = second_q_ops[1:] elif isinstance(second_q_ops, dict): name = problem.main_property_name main_second_q_op = second_q_ops.pop(name, None) if main_second_q_op is None: raise ValueError( f"The main `SecondQuantizedOp` associated with the {name} property cannot be " "`None`." ) aux_second_q_ops = second_q_ops self._main_operator = self._qubit_converter.convert( main_second_q_op, num_particles=problem.num_particles, sector_locator=problem.symmetry_sector_locator, ) aux_ops = self._qubit_converter.convert_match(aux_second_q_ops) if aux_operators is not None: wrapped_aux_operators: ListOrDict[Union[SecondQuantizedOp, PauliSumOp]] = ListOrDict( aux_operators ) for name_aux, aux_op in iter(wrapped_aux_operators): if isinstance(aux_op, SecondQuantizedOp): converted_aux_op = self._qubit_converter.convert_match(aux_op, True) else: converted_aux_op = aux_op if isinstance(aux_ops, list): aux_ops.append(converted_aux_op) elif isinstance(aux_ops, dict): if name_aux in aux_ops.keys(): raise QiskitNatureError( f"The key '{name_aux}' is already taken by an internally constructed " "auxiliary operator! Please use a different name for your custom " "operator." ) aux_ops[name_aux] = converted_aux_op if isinstance(self._solver, MinimumEigensolverFactory): vqe = self._solver.get_solver(problem, self._qubit_converter) else: vqe = self._solver if not isinstance(vqe, VQE): raise QiskitNatureError("The AdaptVQE algorithm requires the use of the VQE solver") if not isinstance(vqe.ansatz, UCC): raise QiskitNatureError("The AdaptVQE algorithm requires the use of the UCC ansatz") # We construct the ansatz once to be able to extract the full set of excitation operators. self._ansatz = copy.deepcopy(vqe.ansatz) self._ansatz._build() self._excitation_pool = copy.deepcopy(self._ansatz.operators) threshold_satisfied = False alternating_sequence = False max_iterations_exceeded = False prev_op_indices: List[int] = [] theta: List[float] = [] max_grad: Tuple[float, Optional[PauliSumOp]] = (0.0, None) iteration = 0 while self._max_iterations is None or iteration < self._max_iterations: iteration += 1 logger.info("--- Iteration #%s ---", str(iteration)) # compute gradients cur_grads = self._compute_gradients(theta, vqe) # pick maximum gradient max_grad_index, max_grad = max( enumerate(cur_grads), key=lambda item: np.abs(item[1][0]) ) # store maximum gradient's index for cycle detection prev_op_indices.append(max_grad_index) # log gradients if logger.isEnabledFor(logging.INFO): gradlog = f"\nGradients in iteration #{str(iteration)}" gradlog += "\nID: Excitation Operator: Gradient <(*) maximum>" for i, grad in enumerate(cur_grads): gradlog += f"\n{str(i)}: {str(grad[1])}: {str(grad[0])}" if grad[1] == max_grad[1]: gradlog += "\t(*)" logger.info(gradlog) if np.abs(max_grad[0]) < self._threshold: logger.info( "Adaptive VQE terminated successfully with a final maximum gradient: %s", str(np.abs(max_grad[0])), ) threshold_satisfied = True break # check indices of picked gradients for cycles if self._check_cyclicity(prev_op_indices): logger.info("Alternating sequence found. Finishing.") logger.info("Final maximum gradient: %s", str(np.abs(max_grad[0]))) alternating_sequence = True break # add new excitation to self._ansatz self._excitation_list.append(max_grad[1]) theta.append(0.0) # run VQE on current Ansatz self._ansatz.operators = self._excitation_list vqe.ansatz = self._ansatz vqe.initial_point = theta raw_vqe_result = vqe.compute_minimum_eigenvalue(self._main_operator) theta = raw_vqe_result.optimal_point.tolist() else: # reached maximum number of iterations max_iterations_exceeded = True logger.info("Maximum number of iterations reached. Finishing.") logger.info("Final maximum gradient: %s", str(np.abs(max_grad[0]))) # once finished evaluate auxiliary operators if any if aux_ops is not None: aux_values = self.evaluate_operators(raw_vqe_result.eigenstate, aux_ops) else: aux_values = None raw_vqe_result.aux_operator_eigenvalues = aux_values if threshold_satisfied: finishing_criterion = "Threshold converged" elif alternating_sequence: finishing_criterion = "Aborted due to cyclicity" elif max_iterations_exceeded: finishing_criterion = "Maximum number of iterations reached" else: raise QiskitNatureError("The algorithm finished due to an unforeseen reason!") electronic_result = problem.interpret(raw_vqe_result) result = AdaptVQEResult() result.combine(electronic_result) result.num_iterations = iteration result.final_max_gradient = max_grad[0] result.finishing_criterion = finishing_criterion logger.info("The final energy is: %s", str(result.computed_energies[0])) return result