From 3f552409fbd4dc39c5b80beda64bf70421c2ed6d Mon Sep 17 00:00:00 2001 From: Evgenii Zheltonozhskii Date: Wed, 29 Jun 2022 11:27:49 +0300 Subject: [PATCH] Fix algorithms mypy errors --- .../amplification_problem.py | 13 +++++++----- .../amplitude_amplifier.py | 5 +++-- .../algorithms/amplitude_amplifiers/grover.py | 4 ++-- qiskit/algorithms/amplitude_estimators/ae.py | 20 ++++++++++-------- .../amplitude_estimator.py | 16 +++++++------- qiskit/algorithms/amplitude_estimators/fae.py | 11 +++++----- qiskit/algorithms/amplitude_estimators/iae.py | 18 ++++++++-------- .../algorithms/amplitude_estimators/mlae.py | 20 +++++++++--------- .../algorithms/eigen_solvers/eigen_solver.py | 6 +++--- qiskit/algorithms/eigen_solvers/vqd.py | 17 ++++++++------- .../algorithms/evolvers/evolution_problem.py | 4 ++-- qiskit/algorithms/factorizers/shor.py | 4 ++-- qiskit/algorithms/linear_solvers/hhl.py | 13 +++++++----- .../linear_solvers/linear_solver.py | 14 ++++++------- .../matrices/linear_system_matrix.py | 9 ++++---- .../linear_solvers/matrices/numpy_matrix.py | 12 ++++++----- .../matrices/tridiagonal_toeplitz.py | 16 +++++++------- .../observables/absolute_average.py | 2 +- .../observables/linear_system_observable.py | 2 +- .../observables/matrix_functional.py | 4 ++-- .../minimum_eigen_solver.py | 6 +++--- .../algorithms/minimum_eigen_solvers/qaoa.py | 3 ++- .../algorithms/minimum_eigen_solvers/vqe.py | 21 +++++++++++-------- qiskit/algorithms/optimizers/aqgd.py | 10 ++++----- .../algorithms/optimizers/gradient_descent.py | 8 ++++--- qiskit/algorithms/optimizers/gsls.py | 4 ++-- qiskit/algorithms/optimizers/l_bfgs_b.py | 4 ++-- qiskit/algorithms/optimizers/optimizer.py | 12 +++++------ qiskit/algorithms/optimizers/p_bfgs.py | 4 ++-- qiskit/algorithms/optimizers/spsa.py | 18 ++++++++-------- qiskit/algorithms/optimizers/umda.py | 18 ++++++++-------- .../phase_estimation_result.py | 2 +- .../phase_estimators/phase_estimator.py | 2 +- qiskit/algorithms/variational_algorithm.py | 14 ++++++------- 34 files changed, 180 insertions(+), 156 deletions(-) diff --git a/qiskit/algorithms/amplitude_amplifiers/amplification_problem.py b/qiskit/algorithms/amplitude_amplifiers/amplification_problem.py index c2908a86aa90..459dd888d939 100644 --- a/qiskit/algorithms/amplitude_amplifiers/amplification_problem.py +++ b/qiskit/algorithms/amplitude_amplifiers/amplification_problem.py @@ -63,7 +63,7 @@ def __init__( if is_good_state is not None: self._is_good_state = is_good_state elif hasattr(oracle, "evaluate_bitstring"): - self._is_good_state = oracle.evaluate_bitstring + self._is_good_state = oracle.evaluate_bitstring # type: ignore[union-attr] else: self._is_good_state = None @@ -167,14 +167,17 @@ def is_good_state(self) -> Callable[[str], bool]: return self._is_good_state # returns None if no is_good_state arg has been set elif isinstance(self._is_good_state, list): if all(isinstance(good_bitstr, str) for good_bitstr in self._is_good_state): - return lambda bitstr: bitstr in self._is_good_state + return lambda bitstr: bitstr in self._is_good_state # type:ignore[operator] else: return lambda bitstr: all( - bitstr[good_index] == "1" # type:ignore - for good_index in self._is_good_state + bitstr[good_index] == "1" # type:ignore[index] + for good_index in self._is_good_state # type:ignore[union-attr] ) - return lambda bitstr: bitstr in self._is_good_state.probabilities_dict() + return ( + lambda bitstr: bitstr + in self._is_good_state.probabilities_dict() # type:ignore[union-attr] + ) @is_good_state.setter def is_good_state( diff --git a/qiskit/algorithms/amplitude_amplifiers/amplitude_amplifier.py b/qiskit/algorithms/amplitude_amplifiers/amplitude_amplifier.py index dd32dc96ec47..eb3d830a7c57 100644 --- a/qiskit/algorithms/amplitude_amplifiers/amplitude_amplifier.py +++ b/qiskit/algorithms/amplitude_amplifiers/amplitude_amplifier.py @@ -11,6 +11,7 @@ # that they have been altered from the originals. """The interface for amplification algorithms and results.""" +from __future__ import annotations from abc import ABC, abstractmethod from typing import Optional, Any, Union, Dict, List @@ -43,9 +44,9 @@ class AmplitudeAmplifierResult(AlgorithmResult): def __init__(self) -> None: super().__init__() - self._top_measurement = None + self._top_measurement: str | None = None self._assignment = None - self._oracle_evaluation = None + self._oracle_evaluation: bool | None = None self._circuit_results = None self._max_probability = None diff --git a/qiskit/algorithms/amplitude_amplifiers/grover.py b/qiskit/algorithms/amplitude_amplifiers/grover.py index 17dd9f00952a..4a0f81511f55 100644 --- a/qiskit/algorithms/amplitude_amplifiers/grover.py +++ b/qiskit/algorithms/amplitude_amplifiers/grover.py @@ -171,7 +171,7 @@ def __init__( sampler = quantum_instance quantum_instance = None - self._quantum_instance = None + self._quantum_instance: QuantumInstance | None = None if quantum_instance is not None: warnings.warn( "The quantum_instance argument has been superseded by the sampler argument. " @@ -422,7 +422,7 @@ class GroverResult(AmplitudeAmplifierResult): def __init__(self) -> None: super().__init__() - self._iterations = None + self._iterations: list[int] | None = None @property def iterations(self) -> List[int]: diff --git a/qiskit/algorithms/amplitude_estimators/ae.py b/qiskit/algorithms/amplitude_estimators/ae.py index 512405f19c9f..186be13d0655 100644 --- a/qiskit/algorithms/amplitude_estimators/ae.py +++ b/qiskit/algorithms/amplitude_estimators/ae.py @@ -471,13 +471,13 @@ class AmplitudeEstimationResult(AmplitudeEstimatorResult): def __init__(self) -> None: super().__init__() - self._num_evaluation_qubits = None - self._mle = None - self._mle_processed = None - self._samples = None - self._samples_processed = None - self._y_measurements = None - self._max_probability = None + self._num_evaluation_qubits: int | None = None + self._mle: float | None = None + self._mle_processed: float | None = None + self._samples: dict[float, float] | None = None + self._samples_processed: dict[float, float] | None = None + self._y_measurements: dict[int, float] | None = None + self._max_probability: float | None = None @property def num_evaluation_qubits(self) -> int: @@ -585,7 +585,7 @@ def integrand(x): def _fisher_confint( result: AmplitudeEstimationResult, alpha: float, observed: bool = False -) -> list[float]: +) -> Tuple[float, float]: """Compute the Fisher information confidence interval for the MLE of the previous run. Args: @@ -605,7 +605,9 @@ def _fisher_confint( return tuple(result.post_processing(bound) for bound in confint) -def _likelihood_ratio_confint(result: AmplitudeEstimationResult, alpha: float) -> list[float]: +def _likelihood_ratio_confint( + result: AmplitudeEstimationResult, alpha: float +) -> Tuple[float, float]: """Compute the likelihood ratio confidence interval for the MLE of the previous run. Args: diff --git a/qiskit/algorithms/amplitude_estimators/amplitude_estimator.py b/qiskit/algorithms/amplitude_estimators/amplitude_estimator.py index eb2e5a7f4f67..3a0d196d30f0 100644 --- a/qiskit/algorithms/amplitude_estimators/amplitude_estimator.py +++ b/qiskit/algorithms/amplitude_estimators/amplitude_estimator.py @@ -40,14 +40,14 @@ class AmplitudeEstimatorResult(AlgorithmResult): def __init__(self) -> None: super().__init__() - self._circuit_results = None - self._shots = None - self._estimation = None - self._estimation_processed = None - self._num_oracle_queries = None - self._post_processing = None - self._confidence_interval = None - self._confidence_interval_processed = None + self._circuit_results: Optional[Union[np.ndarray, Dict[str, int]]] = None + self._shots: Optional[int] = None + self._estimation: Optional[float] = None + self._estimation_processed: Optional[float] = None + self._num_oracle_queries: Optional[int] = None + self._post_processing: Optional[Callable[[float], float]] = None + self._confidence_interval: Optional[Tuple[float, float]] = None + self._confidence_interval_processed: Optional[Tuple[float, float]] = None @property def circuit_results(self) -> np.ndarray | dict[str, int] | None: diff --git a/qiskit/algorithms/amplitude_estimators/fae.py b/qiskit/algorithms/amplitude_estimators/fae.py index 697556840df0..e510f53edead 100644 --- a/qiskit/algorithms/amplitude_estimators/fae.py +++ b/qiskit/algorithms/amplitude_estimators/fae.py @@ -314,7 +314,7 @@ def cos_estimate(power, shots): theta = np.mean(theta_ci) rescaling = 4 if self._rescale else 1 value = (rescaling * np.sin(theta)) ** 2 - value_ci = [(rescaling * np.sin(x)) ** 2 for x in theta_ci] + value_ci = [(rescaling * np.sin(x)) ** 2 for x in theta_ci] # TODO should be tuple? result = FasterAmplitudeEstimationResult() result.num_oracle_queries = self._num_oracle_calls @@ -343,14 +343,15 @@ class FasterAmplitudeEstimationResult(AmplitudeEstimatorResult): def __init__(self) -> None: super().__init__() - self._success_probability = None - self._num_steps = None - self._num_first_state_steps = None - self._theta_intervals = None + self._success_probability: Optional[int] = None + self._num_steps: Optional[int] = None + self._num_first_state_steps: Optional[int] = None + self._theta_intervals: Optional[List[List[float]]] = None @property def success_probability(self) -> int: """Return the success probability of the algorithm.""" + # TODO: should be float? return self._success_probability @success_probability.setter diff --git a/qiskit/algorithms/amplitude_estimators/iae.py b/qiskit/algorithms/amplitude_estimators/iae.py index 59a4429d0bf4..af7d8357b5fc 100644 --- a/qiskit/algorithms/amplitude_estimators/iae.py +++ b/qiskit/algorithms/amplitude_estimators/iae.py @@ -536,15 +536,15 @@ class IterativeAmplitudeEstimationResult(AmplitudeEstimatorResult): def __init__(self) -> None: super().__init__() - self._alpha = None - self._epsilon_target = None - self._epsilon_estimated = None - self._epsilon_estimated_processed = None - self._estimate_intervals = None - self._theta_intervals = None - self._powers = None - self._ratios = None - self._confidence_interval_processed = None + self._alpha: Optional[float] = None + self._epsilon_target: Optional[float] = None + self._epsilon_estimated: Optional[float] = None + self._epsilon_estimated_processed: Optional[float] = None + self._estimate_intervals: Optional[List[List[float]]] = None + self._theta_intervals: Optional[List[List[float]]] = None + self._powers: Optional[List[int]] = None + self._ratios: Optional[List[float]] = None + self._confidence_interval_processed: Optional[Tuple[float, float]] = None @property def alpha(self) -> float: diff --git a/qiskit/algorithms/amplitude_estimators/mlae.py b/qiskit/algorithms/amplitude_estimators/mlae.py index 8d46e1a2c21e..f6d7344883a2 100644 --- a/qiskit/algorithms/amplitude_estimators/mlae.py +++ b/qiskit/algorithms/amplitude_estimators/mlae.py @@ -240,7 +240,7 @@ def compute_confidence_interval( AlgorithmError: If `run()` hasn't been called yet. NotImplementedError: If the method `kind` is not supported. """ - interval = None + interval: typing.Tuple[float, float] | None = None # if statevector simulator the estimate is exact if all(isinstance(data, (list, np.ndarray)) for data in result.circuit_results): @@ -265,7 +265,7 @@ def compute_confidence_interval( def compute_mle( self, - circuit_results: list[dict[str, int]] | list[np.ndarray], + circuit_results: list[dict[str, int] | np.ndarray], estimation_problem: EstimationProblem, num_state_qubits: int | None = None, return_counts: bool = False, @@ -415,11 +415,11 @@ class MaximumLikelihoodAmplitudeEstimationResult(AmplitudeEstimatorResult): def __init__(self) -> None: super().__init__() - self._theta = None - self._minimizer = None - self._good_counts = None - self._evaluation_schedule = None - self._fisher_information = None + self._theta: float | None = None + self._minimizer: callable | None = None + self._good_counts: list[float] | None = None + self._evaluation_schedule: list[int] | None = None + self._fisher_information: float | None = None @property def theta(self) -> float: @@ -579,7 +579,7 @@ def _likelihood_ratio_confint( result: MaximumLikelihoodAmplitudeEstimationResult, alpha: float = 0.05, nevals: int | None = None, -) -> list[float]: +) -> typing.Tuple[float, float]: """Compute the likelihood-ratio confidence interval. Args: @@ -627,7 +627,7 @@ def loglikelihood(theta, one_counts, all_counts): def _get_counts( - circuit_results: list[np.ndarray | list[float], dict[str, int]], + circuit_results: typing.Sequence[np.ndarray | list[float] | dict[str, int]], estimation_problem: EstimationProblem, num_state_qubits: int, ) -> tuple[list[float], list[int]]: @@ -640,7 +640,7 @@ def _get_counts( AlgorithmError: If self.run() has not been called yet. """ one_hits = [] # h_k: how often 1 has been measured, for a power Q^(m_k) - all_hits = [] # shots_k: how often has been measured at a power Q^(m_k) + all_hits: np.ndarray | list[float] = [] # shots_k: how often has been measured at a power Q^(m_k) if all(isinstance(data, (list, np.ndarray)) for data in circuit_results): probabilities = [] num_qubits = int(np.log2(len(circuit_results[0]))) # the total number of qubits diff --git a/qiskit/algorithms/eigen_solvers/eigen_solver.py b/qiskit/algorithms/eigen_solvers/eigen_solver.py index a013b5c827cc..4fc7475ec1c4 100644 --- a/qiskit/algorithms/eigen_solvers/eigen_solver.py +++ b/qiskit/algorithms/eigen_solvers/eigen_solver.py @@ -97,9 +97,9 @@ class EigensolverResult(AlgorithmResult): ) def __init__(self) -> None: super().__init__() - self._eigenvalues = None - self._eigenstates = None - self._aux_operator_eigenvalues = None + self._eigenvalues: Optional[np.ndarray] = None + self._eigenstates: Optional[np.ndarray] = None + self._aux_operator_eigenvalues: Optional[List[ListOrDict[Tuple[complex, complex]]]] = None @property def eigenvalues(self) -> Optional[np.ndarray]: diff --git a/qiskit/algorithms/eigen_solvers/vqd.py b/qiskit/algorithms/eigen_solvers/vqd.py index d14ac038e1fe..1ffce32ab580 100644 --- a/qiskit/algorithms/eigen_solvers/vqd.py +++ b/qiskit/algorithms/eigen_solvers/vqd.py @@ -175,27 +175,27 @@ def __init__( # set ansatz -- still supporting pre 0.18.0 sorting - self._ansatz = None + self._ansatz: Optional[QuantumCircuit] = None self.ansatz = ansatz self.k = k self.betas = betas - self._optimizer = None + self._optimizer: Optional[Optimizer] = None self.optimizer = optimizer - self._initial_point = None + self._initial_point: Optional[np.ndarray] = None self.initial_point = initial_point - self._gradient = None + self._gradient: Optional[Union[GradientBase, Callable]] = None self.gradient = gradient - self._quantum_instance = None + self._quantum_instance: Optional[QuantumInstance] = None if quantum_instance is not None: self.quantum_instance = quantum_instance self._eval_time = None self._eval_count = 0 - self._callback = None + self._callback: Optional[Callable[[int, np.ndarray, float, float], None]] = None self.callback = callback logger.info(self.print_settings()) @@ -663,7 +663,10 @@ def get_energy_evaluation( operator: OperatorBase, return_expectation: bool = False, prev_states: Optional[List[np.ndarray]] = None, - ) -> Callable[[np.ndarray], Union[float, List[float]]]: + ) -> Union[ + Callable[[np.ndarray], Union[float, List[float]]], + Tuple[Callable[[np.ndarray], Union[float, List[float]]], ExpectationBase], + ]: """Returns a function handle to evaluates the energy at given parameters for the ansatz. This return value is the objective function to be passed to the optimizer for evaluation. diff --git a/qiskit/algorithms/evolvers/evolution_problem.py b/qiskit/algorithms/evolvers/evolution_problem.py index cd34c5a34f8a..9355c32521e9 100644 --- a/qiskit/algorithms/evolvers/evolution_problem.py +++ b/qiskit/algorithms/evolvers/evolution_problem.py @@ -12,7 +12,7 @@ """Evolution problem class.""" -from typing import Union, Optional, Dict +from typing import Union, Optional, Dict, Set from qiskit import QuantumCircuit from qiskit.circuit import Parameter @@ -107,7 +107,7 @@ def validate_params(self) -> None: t_param_set = set() if self.t_param is not None: t_param_set.add(self.t_param) - hamiltonian_dict_param_set = set() + hamiltonian_dict_param_set: Set[Parameter] = set() if self.param_value_dict is not None: hamiltonian_dict_param_set = hamiltonian_dict_param_set.union( set(self.param_value_dict.keys()) diff --git a/qiskit/algorithms/factorizers/shor.py b/qiskit/algorithms/factorizers/shor.py index 7f700e768898..601750112870 100644 --- a/qiskit/algorithms/factorizers/shor.py +++ b/qiskit/algorithms/factorizers/shor.py @@ -68,7 +68,7 @@ def __init__(self, quantum_instance: Optional[Union[QuantumInstance, Backend]] = quantum_instance: Quantum Instance or Backend """ - self._quantum_instance = None + self._quantum_instance: Optional[QuantumInstance] = None if quantum_instance: self.quantum_instance = quantum_instance @@ -496,7 +496,7 @@ class ShorResult(AlgorithmResult): def __init__(self) -> None: super().__init__() - self._factors = [] + self._factors: Optional[List[List[int]]] = [] self._total_counts = 0 self._successful_counts = 0 diff --git a/qiskit/algorithms/linear_solvers/hhl.py b/qiskit/algorithms/linear_solvers/hhl.py index 131e2bfcbdbc..eb39631e6e54 100644 --- a/qiskit/algorithms/linear_solvers/hhl.py +++ b/qiskit/algorithms/linear_solvers/hhl.py @@ -386,14 +386,14 @@ def construct_circuit( # Set the tolerance for the matrix approximation if hasattr(matrix_circuit, "tolerance"): - matrix_circuit.tolerance = self._epsilon_a + matrix_circuit.tolerance = self._epsilon_a # type: ignore[attr-defined] # check if the matrix can calculate the condition number and store the upper bound if ( hasattr(matrix_circuit, "condition_bounds") - and matrix_circuit.condition_bounds() is not None + and matrix_circuit.condition_bounds() is not None # type: ignore[attr-defined] ): - kappa = matrix_circuit.condition_bounds()[1] + kappa = matrix_circuit.condition_bounds()[1] # type: ignore[attr-defined] else: kappa = 1 # Update the number of qubits required to represent the eigenvalues @@ -402,8 +402,11 @@ def construct_circuit( nl = max(nb + 1, int(np.ceil(np.log2(kappa + 1)))) + neg_vals # check if the matrix can calculate bounds for the eigenvalues - if hasattr(matrix_circuit, "eigs_bounds") and matrix_circuit.eigs_bounds() is not None: - lambda_min, lambda_max = matrix_circuit.eigs_bounds() + if ( + hasattr(matrix_circuit, "eigs_bounds") + and matrix_circuit.eigs_bounds() is not None # type: ignore[attr-defined] + ): + lambda_min, lambda_max = matrix_circuit.eigs_bounds() # type: ignore[attr-defined] # Constant so that the minimum eigenvalue is represented exactly, since it contributes # the most to the solution of the system. -1 to take into account the sign qubit delta = self._get_delta(nl - neg_vals, lambda_min, lambda_max) diff --git a/qiskit/algorithms/linear_solvers/linear_solver.py b/qiskit/algorithms/linear_solvers/linear_solver.py index 97a68226ebb9..6dc7dbdfbbbd 100644 --- a/qiskit/algorithms/linear_solvers/linear_solver.py +++ b/qiskit/algorithms/linear_solvers/linear_solver.py @@ -13,7 +13,7 @@ """An abstract class for linear systems solvers.""" from abc import ABC, abstractmethod -from typing import Union, Optional, List, Callable +from typing import Union, Optional, List, Callable, SupportsFloat import numpy as np from qiskit import QuantumCircuit @@ -40,10 +40,10 @@ def __init__(self) -> None: super().__init__() # Set the default to None, if the algorithm knows how to calculate it can override it. - self._state = None - self._observable = None - self._euclidean_norm = None - self._circuit_results = None + self._state: Optional[Union[QuantumCircuit, np.ndarray]] = None + self._observable: Optional[Union[float, List[float]]] = None + self._euclidean_norm: Optional[SupportsFloat] = None + self._circuit_results: Optional[Union[List[float], List[Result]]] = None @property def observable(self) -> Union[float, List[float]]: @@ -74,12 +74,12 @@ def state(self, state: Union[QuantumCircuit, np.ndarray]) -> None: self._state = state @property - def euclidean_norm(self) -> float: + def euclidean_norm(self) -> SupportsFloat: """return the euclidean norm if the algorithm knows how to calculate it""" return self._euclidean_norm @euclidean_norm.setter - def euclidean_norm(self, norm: float) -> None: + def euclidean_norm(self, norm: SupportsFloat) -> None: """Set the euclidean norm of the solution. Args: diff --git a/qiskit/algorithms/linear_solvers/matrices/linear_system_matrix.py b/qiskit/algorithms/linear_solvers/matrices/linear_system_matrix.py index 26e53860dc1f..37ce9b75f8db 100644 --- a/qiskit/algorithms/linear_solvers/matrices/linear_system_matrix.py +++ b/qiskit/algorithms/linear_solvers/matrices/linear_system_matrix.py @@ -13,7 +13,7 @@ """An abstract class for matrices input to the linear systems solvers in Qiskit.""" from abc import ABC, abstractmethod -from typing import Tuple +from typing import Tuple, Optional from qiskit import QuantumCircuit from qiskit.circuit.library import BlueprintCircuit @@ -44,9 +44,10 @@ def __init__( super().__init__(name=name) # define internal parameters - self._num_state_qubits = None - self._tolerance = None - self._evolution_time = None # makes sure the eigenvalues are contained in [0,1) + self._num_state_qubits: Optional[int] = None + self._tolerance: Optional[float] = None + # makes sure the eigenvalues are contained in [0,1) + self._evolution_time: Optional[float] = None # store parameters self.num_state_qubits = num_state_qubits diff --git a/qiskit/algorithms/linear_solvers/matrices/numpy_matrix.py b/qiskit/algorithms/linear_solvers/matrices/numpy_matrix.py index fdf30017c925..d1a11808b128 100644 --- a/qiskit/algorithms/linear_solvers/matrices/numpy_matrix.py +++ b/qiskit/algorithms/linear_solvers/matrices/numpy_matrix.py @@ -12,7 +12,7 @@ """Hamiltonian simulation of matrices given as numpy arrays.""" -from typing import Tuple +from typing import Tuple, Optional import numpy as np import scipy as sp @@ -68,9 +68,11 @@ def __init__( """ # define internal parameters - self._num_state_qubits = None - self._tolerance = None - self._evolution_time = None # makes sure the eigenvalues are contained in [0,1) + self._num_state_qubits: Optional[int] = None + self._tolerance: Optional[float] = None + self._evolution_time: Optional[ + float + ] = None # makes sure the eigenvalues are contained in [0,1) self._matrix = None super().__init__( @@ -218,5 +220,5 @@ def power(self, power: int, matrix_power: bool = False) -> QuantumCircuit: """ qc = QuantumCircuit(self.num_state_qubits) evolved = sp.linalg.expm(1j * self.matrix * self.evolution_time) - qc.unitary(evolved, qc.qubits) + qc.unitary(evolved, qc.qubits) # type: ignore[attr-defined] return qc.power(power) diff --git a/qiskit/algorithms/linear_solvers/matrices/tridiagonal_toeplitz.py b/qiskit/algorithms/linear_solvers/matrices/tridiagonal_toeplitz.py index 6dda2716b680..833be2e85243 100644 --- a/qiskit/algorithms/linear_solvers/matrices/tridiagonal_toeplitz.py +++ b/qiskit/algorithms/linear_solvers/matrices/tridiagonal_toeplitz.py @@ -12,7 +12,7 @@ """Hamiltonian simulation of tridiagonal Toeplitz symmetric matrices.""" -from typing import Tuple +from typing import Tuple, Optional import numpy as np from scipy.sparse import diags @@ -85,11 +85,13 @@ def __init__( name: The name of the object. """ # define internal parameters - self._num_state_qubits = None + self._num_state_qubits: Optional[int] = None self._main_diag = None self._off_diag = None - self._tolerance = None - self._evolution_time = None # makes sure the eigenvalues are contained in [0,1) + self._tolerance: Optional[float] = None + self._evolution_time: Optional[ + float + ] = None # makes sure the eigenvalues are contained in [0,1) self._trotter_steps = None # store parameters @@ -307,7 +309,7 @@ def control(num_ctrl_qubits=1, label=None, ctrl_state=None): qc_control.p(theta, 0) return qc_control - qc.control = control + qc.control = control # type: ignore[assignment] return qc def _off_diag_circ(self, theta: float = 1) -> QuantumCircuit: @@ -405,7 +407,7 @@ def control(num_ctrl_qubits=1, label=None, ctrl_state=None): qc_control.cx(qr[i], qr[i + 1]) return qc_control - qc.control = control + qc.control = control # type: ignore[assignment] return qc def inverse(self): @@ -483,5 +485,5 @@ def control(num_ctrl_qubits=1, label=None, ctrl_state=None): ) return qc - qc_raw.control = control + qc_raw.control = control # type: ignore[assignment] return qc_raw diff --git a/qiskit/algorithms/linear_solvers/observables/absolute_average.py b/qiskit/algorithms/linear_solvers/observables/absolute_average.py index 300c31edaed9..035ce8e134bc 100644 --- a/qiskit/algorithms/linear_solvers/observables/absolute_average.py +++ b/qiskit/algorithms/linear_solvers/observables/absolute_average.py @@ -119,7 +119,7 @@ def post_processing( return np.real(np.sqrt(solution / (2**num_qubits)) / scaling) - def evaluate_classically(self, solution: Union[np.array, QuantumCircuit]) -> float: + def evaluate_classically(self, solution: Union[np.ndarray, QuantumCircuit]) -> float: """Evaluates the given observable on the solution to the linear system. Args: diff --git a/qiskit/algorithms/linear_solvers/observables/linear_system_observable.py b/qiskit/algorithms/linear_solvers/observables/linear_system_observable.py index fd6ea2339738..0c24d58a234f 100644 --- a/qiskit/algorithms/linear_solvers/observables/linear_system_observable.py +++ b/qiskit/algorithms/linear_solvers/observables/linear_system_observable.py @@ -72,7 +72,7 @@ def post_processing( raise NotImplementedError @abstractmethod - def evaluate_classically(self, solution: Union[np.array, QuantumCircuit]) -> float: + def evaluate_classically(self, solution: Union[np.ndarray, QuantumCircuit]) -> float: """Calculates the analytical value of the given observable from the solution vector to the linear system. diff --git a/qiskit/algorithms/linear_solvers/observables/matrix_functional.py b/qiskit/algorithms/linear_solvers/observables/matrix_functional.py index ca0cfecf16bc..b66493e2e23e 100644 --- a/qiskit/algorithms/linear_solvers/observables/matrix_functional.py +++ b/qiskit/algorithms/linear_solvers/observables/matrix_functional.py @@ -163,13 +163,13 @@ def post_processing( raise ValueError("Solution probabilities must be given in list form.") # Calculate the value from the off-diagonal elements - off_val = 0 + off_val = 0.0 for i in range(1, len(solution), 2): off_val += (solution[i] - solution[i + 1]) / (scaling**2) main_val = solution[0] / (scaling**2) return np.real(self._main_diag * main_val + self._off_diag * off_val) - def evaluate_classically(self, solution: Union[np.array, QuantumCircuit]) -> float: + def evaluate_classically(self, solution: Union[np.ndarray, QuantumCircuit]) -> float: """Evaluates the given observable on the solution to the linear system. Args: diff --git a/qiskit/algorithms/minimum_eigen_solvers/minimum_eigen_solver.py b/qiskit/algorithms/minimum_eigen_solvers/minimum_eigen_solver.py index 373876a9e046..ef642a16d9f8 100644 --- a/qiskit/algorithms/minimum_eigen_solvers/minimum_eigen_solver.py +++ b/qiskit/algorithms/minimum_eigen_solvers/minimum_eigen_solver.py @@ -101,9 +101,9 @@ class MinimumEigensolverResult(AlgorithmResult): ) def __init__(self) -> None: super().__init__() - self._eigenvalue = None - self._eigenstate = None - self._aux_operator_eigenvalues = None + self._eigenvalue: Optional[complex] = None + self._eigenstate: Optional[np.ndarray] = None + self._aux_operator_eigenvalues: Optional[ListOrDict[Tuple[complex, complex]]] = None @property def eigenvalue(self) -> Optional[complex]: diff --git a/qiskit/algorithms/minimum_eigen_solvers/qaoa.py b/qiskit/algorithms/minimum_eigen_solvers/qaoa.py index e650ee349cb1..c8da147c7f8d 100644 --- a/qiskit/algorithms/minimum_eigen_solvers/qaoa.py +++ b/qiskit/algorithms/minimum_eigen_solvers/qaoa.py @@ -126,7 +126,7 @@ def __init__( self._reps = reps self._mixer = mixer self._initial_state = initial_state - self._cost_operator = None + self._cost_operator: Optional[OperatorBase] = None with warnings.catch_warnings(): warnings.simplefilter("ignore") @@ -143,6 +143,7 @@ def __init__( ) def _check_operator_ansatz(self, operator: OperatorBase) -> OperatorBase: + # TODO: should return something? # Recreates a circuit based on operator parameter. if operator != self._cost_operator: self._cost_operator = operator diff --git a/qiskit/algorithms/minimum_eigen_solvers/vqe.py b/qiskit/algorithms/minimum_eigen_solvers/vqe.py index 286298620420..ca14c4d089d6 100755 --- a/qiskit/algorithms/minimum_eigen_solvers/vqe.py +++ b/qiskit/algorithms/minimum_eigen_solvers/vqe.py @@ -195,30 +195,30 @@ def __init__( self.expectation = expectation self._include_custom = include_custom - self._ansatz = None + self._ansatz: QuantumCircuit | None = None self.ansatz = ansatz - self._optimizer = None + self._optimizer: Optimizer | None = None self.optimizer = optimizer - self._initial_point = None + self._initial_point: np.ndarray | None = None self.initial_point = initial_point - self._gradient = None + self._gradient: GradientBase | callable | None = None self.gradient = gradient - self._quantum_instance = None + self._quantum_instance: QuantumInstance | None = None if quantum_instance is not None: self.quantum_instance = quantum_instance self._eval_time = None self._eval_count = 0 - self._callback = None + self._callback: Optional[Callable[[int, np.ndarray, float, float], None]] = None self.callback = callback logger.info(self.print_settings()) # TODO remove this once the stateful methods are deleted - self._ret = None + self._ret: Optional[VQEResult] = None @property def ansatz(self) -> QuantumCircuit: @@ -582,7 +582,10 @@ def get_energy_evaluation( self, operator: OperatorBase, return_expectation: bool = False, - ) -> Callable[[np.ndarray], Union[float, List[float]]]: + ) -> Union[ + Callable[[np.ndarray], Union[float, List[float]]], + Tuple[Callable[[np.ndarray], Union[float, List[float]]], ExpectationBase], + ]: """Returns a function handle to evaluates the energy at given parameters for the ansatz. This is the objective function to be passed to the optimizer that is used for evaluation. @@ -677,7 +680,7 @@ def __init__(self) -> None: with warnings.catch_warnings(): warnings.simplefilter("ignore") super().__init__() - self._cost_function_evals = None + self._cost_function_evals: Optional[int] = None @property def cost_function_evals(self) -> Optional[int]: diff --git a/qiskit/algorithms/optimizers/aqgd.py b/qiskit/algorithms/optimizers/aqgd.py index 5ffb0f849599..36affa5e68c1 100644 --- a/qiskit/algorithms/optimizers/aqgd.py +++ b/qiskit/algorithms/optimizers/aqgd.py @@ -98,7 +98,7 @@ def __init__( # state self._avg_objval = None - self._prev_param = None + self._prev_param: Optional[np.ndarray] = None self._eval_count = 0 # function evaluations self._prev_loss = [] # type: List[float] self._prev_grad = [] # type: List[List[float]] @@ -128,8 +128,8 @@ def settings(self) -> Dict[str, Any]: } def _compute_objective_fn_and_gradient( - self, params: List[float], obj: Callable - ) -> Tuple[float, np.array]: + self, params: Union[np.ndarray, List[float]], obj: Callable + ) -> Tuple[float, np.ndarray]: """ Obtains the objective function value for params and the analytical quantum derivatives of the objective function with respect to each parameter. Requires @@ -172,7 +172,7 @@ def _update( mprev: np.ndarray, step_size: float, momentum_coeff: float, - ) -> Tuple[List[float], List[float]]: + ) -> Tuple[np.ndarray, np.ndarray]: """ Updates full parameter array based on a step that is a convex combination of the gradient and previous momentum @@ -232,7 +232,7 @@ def _converged_objective(self, objval: float, tol: float, window_size: int) -> b return True return False - def _converged_parameter(self, parameter: List[float], tol: float) -> bool: + def _converged_parameter(self, parameter: np.ndarray, tol: float) -> bool: """ Tests convergence based on change in parameter diff --git a/qiskit/algorithms/optimizers/gradient_descent.py b/qiskit/algorithms/optimizers/gradient_descent.py index a354aa383a2b..0529ca5654a9 100644 --- a/qiskit/algorithms/optimizers/gradient_descent.py +++ b/qiskit/algorithms/optimizers/gradient_descent.py @@ -13,13 +13,13 @@ """A standard gradient descent optimizer.""" from dataclasses import dataclass, field -from typing import Dict, Any, Union, Callable, Optional, Tuple, List, Iterator +from typing import Dict, Any, Union, Callable, Optional, Tuple, List, Iterator, SupportsFloat import numpy as np from .optimizer import Optimizer, OptimizerSupportLevel, OptimizerResult, POINT from .steppable_optimizer import AskData, TellData, OptimizerState, SteppableOptimizer from .optimizer_utils import LearningRate -CALLBACK = Callable[[int, np.ndarray, float, float], None] +CALLBACK = Callable[[int, np.ndarray, float, SupportsFloat], None] @dataclass @@ -264,7 +264,9 @@ def settings(self) -> Dict[str, Any]: # if learning rate or perturbation are custom iterators expand them if callable(self.learning_rate): iterator = self.learning_rate() - learning_rate = np.array([next(iterator) for _ in range(self.maxiter)]) + learning_rate: float | np.ndarray = np.array( + [next(iterator) for _ in range(self.maxiter)] + ) else: learning_rate = self.learning_rate diff --git a/qiskit/algorithms/optimizers/gsls.py b/qiskit/algorithms/optimizers/gsls.py index 2649037f4170..56ee4cc0b077 100644 --- a/qiskit/algorithms/optimizers/gsls.py +++ b/qiskit/algorithms/optimizers/gsls.py @@ -12,7 +12,7 @@ """Line search with Gaussian-smoothed samples on a sphere.""" -from typing import Dict, Optional, Tuple, List, Callable, Any +from typing import Dict, Optional, Tuple, List, Callable, Any, SupportsFloat import numpy as np from qiskit.utils import algorithm_globals @@ -169,7 +169,7 @@ def ls_optimize( prev_directions, prev_sample_set_x, prev_sample_set_y = None, None, None consecutive_fail_iter = 0 alpha = self._options["initial_step_size"] - grad_norm = np.inf + grad_norm: SupportsFloat = np.inf sample_set_size = int(round(self._options["sample_size_factor"] * n)) # Initial point diff --git a/qiskit/algorithms/optimizers/l_bfgs_b.py b/qiskit/algorithms/optimizers/l_bfgs_b.py index 6b26ee80c6b4..6d072448dfbe 100644 --- a/qiskit/algorithms/optimizers/l_bfgs_b.py +++ b/qiskit/algorithms/optimizers/l_bfgs_b.py @@ -12,7 +12,7 @@ """Limited-memory BFGS Bound optimizer.""" -from typing import Optional +from typing import Optional, SupportsFloat import numpy as np @@ -50,7 +50,7 @@ def __init__( self, maxfun: int = 15000, maxiter: int = 15000, - ftol: float = 10 * np.finfo(float).eps, + ftol: SupportsFloat = 10 * np.finfo(float).eps, iprint: int = -1, eps: float = 1e-08, options: Optional[dict] = None, diff --git a/qiskit/algorithms/optimizers/optimizer.py b/qiskit/algorithms/optimizers/optimizer.py index 6f2e4e1077f9..3d9fbd383af4 100644 --- a/qiskit/algorithms/optimizers/optimizer.py +++ b/qiskit/algorithms/optimizers/optimizer.py @@ -41,12 +41,12 @@ class OptimizerResult(AlgorithmResult): def __init__(self) -> None: super().__init__() - self._x = None # pylint: disable=invalid-name - self._fun = None - self._jac = None - self._nfev = None - self._njev = None - self._nit = None + self._x: Optional[POINT] = None # pylint: disable=invalid-name + self._fun: Optional[float] = None + self._jac: Optional[POINT] = None + self._nfev: Optional[int] = None + self._njev: Optional[int] = None + self._nit: Optional[int] = None @property def x(self) -> Optional[POINT]: diff --git a/qiskit/algorithms/optimizers/p_bfgs.py b/qiskit/algorithms/optimizers/p_bfgs.py index e3aa811a4184..e0129cfe1c1c 100644 --- a/qiskit/algorithms/optimizers/p_bfgs.py +++ b/qiskit/algorithms/optimizers/p_bfgs.py @@ -16,7 +16,7 @@ import multiprocessing import platform import sys -from typing import Optional, List, Tuple, Callable +from typing import Optional, List, Tuple, Callable, SupportsFloat import numpy as np @@ -49,7 +49,7 @@ class P_BFGS(SciPyOptimizer): # pylint: disable=invalid-name def __init__( self, maxfun: int = 1000, - ftol: float = 10 * np.finfo(float).eps, + ftol: SupportsFloat = 10 * np.finfo(float).eps, iprint: int = -1, max_processes: Optional[int] = None, options: Optional[dict] = None, diff --git a/qiskit/algorithms/optimizers/spsa.py b/qiskit/algorithms/optimizers/spsa.py index a7f4f93efdaa..caaa525776f0 100644 --- a/qiskit/algorithms/optimizers/spsa.py +++ b/qiskit/algorithms/optimizers/spsa.py @@ -15,7 +15,7 @@ This implementation allows both, standard first-order as well as second-order SPSA. """ -from typing import Iterator, Optional, Union, Callable, Tuple, Dict, List, Any +from typing import Iterator, Optional, Union, Callable, Tuple, Dict, List, Any, SupportsFloat import logging import warnings from time import time @@ -30,8 +30,8 @@ from .optimizer import Optimizer, OptimizerSupportLevel, OptimizerResult, POINT # number of function evaluations, parameters, loss, stepsize, accepted -CALLBACK = Callable[[int, np.ndarray, float, float, bool], None] -TERMINATIONCHECKER = Callable[[int, np.ndarray, float, float, bool], bool] +CALLBACK = Callable[[int, np.ndarray, float, SupportsFloat, bool], None] +TERMINATIONCHECKER = Callable[[int, np.ndarray, float, SupportsFloat, bool], bool] logger = logging.getLogger(__name__) @@ -165,8 +165,8 @@ def __init__( blocking: bool = False, allowed_increase: Optional[float] = None, trust_region: bool = False, - learning_rate: Optional[Union[float, np.array, Callable[[], Iterator]]] = None, - perturbation: Optional[Union[float, np.array, Callable[[], Iterator]]] = None, + learning_rate: Optional[Union[float, np.ndarray, Callable[[], Iterator]]] = None, + perturbation: Optional[Union[float, np.ndarray, Callable[[], Iterator]]] = None, last_avg: int = 1, resamplings: Union[int, Dict[int, int]] = 1, perturbation_dims: Optional[int] = None, @@ -275,8 +275,8 @@ def __init__( self.initial_hessian = initial_hessian # runtime arguments - self._nfev = None # the number of function evaluations - self._smoothed_hessian = None # smoothed average of the Hessians + self._nfev: Optional[int] = None # the number of function evaluations + self._smoothed_hessian: Optional[np.ndarray] = None # smoothed average of the Hessians @staticmethod def calibrate( @@ -289,7 +289,7 @@ def calibrate( gamma: float = 0.101, modelspace: bool = False, max_evals_grouped: int = 1, - ) -> Tuple[Iterator[float], Iterator[float]]: + ) -> Tuple[Callable, Callable]: r"""Calibrate SPSA parameters with a powerseries as learning rate and perturbation coeffs. The powerseries are: @@ -332,7 +332,7 @@ def calibrate( losses = _batch_evaluate(loss, points, max_evals_grouped) - avg_magnitudes = 0 + avg_magnitudes = 0.0 for i in range(steps): delta = losses[2 * i] - losses[2 * i + 1] avg_magnitudes += np.abs(delta / (2 * c)) diff --git a/qiskit/algorithms/optimizers/umda.py b/qiskit/algorithms/optimizers/umda.py index b93df1b86e4f..ef65dbbcd0ef 100644 --- a/qiskit/algorithms/optimizers/umda.py +++ b/qiskit/algorithms/optimizers/umda.py @@ -131,22 +131,22 @@ def __init__(self, maxiter: int = 100, size_gen: int = 20, alpha: float = 0.5) - self.size_gen = size_gen self.maxiter = maxiter self.alpha = alpha - self._vector = None + self._vector: Optional[np.ndarray] = None # initialization of generation - self._generation = None + self._generation: Optional[np.ndarray] = None self._dead_iter = int(self._maxiter / 5) self._truncation_length = int(size_gen * alpha) super().__init__() - self._best_cost_global = None - self._best_ind_global = None - self._evaluations = None + self._best_cost_global: Optional[float] = None + self._best_ind_global: Optional[int] = None + self._evaluations: Optional[np.ndarray] = None - self._n_variables = None + self._n_variables: Optional[int] = None - def _initialization(self): + def _initialization(self) -> np.ndarray: vector = np.zeros((4, self._n_variables)) vector[0, :] = np.pi # mu @@ -203,7 +203,7 @@ def minimize( not_better_count = 0 result = OptimizerResult() - self._n_variables = len(x0) + self._n_variables = len(x0) # TODO: what if x0 is float? self._best_cost_global = 999999999999 self._best_ind_global = 9999999 history = [] @@ -221,7 +221,7 @@ def minimize( self._truncation() self._update_vector() - best_mae_local = min(self._evaluations) + best_mae_local: float = min(self._evaluations) history.append(best_mae_local) best_ind_local = np.where(self._evaluations == best_mae_local)[0][0] diff --git a/qiskit/algorithms/phase_estimators/phase_estimation_result.py b/qiskit/algorithms/phase_estimators/phase_estimation_result.py index 0a9b8299758b..f860d21cc960 100644 --- a/qiskit/algorithms/phase_estimators/phase_estimation_result.py +++ b/qiskit/algorithms/phase_estimators/phase_estimation_result.py @@ -66,7 +66,7 @@ def circuit_result(self) -> Result: """ return self._circuit_result - @property + @property # type: ignore @deprecate_function( """The 'PhaseEstimationResult.most_likely_phase' attribute is deprecated as of 0.18.0 and will be removed no earlier than 3 months diff --git a/qiskit/algorithms/phase_estimators/phase_estimator.py b/qiskit/algorithms/phase_estimators/phase_estimator.py index 09f8113e5f4a..bd5352931235 100644 --- a/qiskit/algorithms/phase_estimators/phase_estimator.py +++ b/qiskit/algorithms/phase_estimators/phase_estimator.py @@ -46,7 +46,7 @@ def _get_reversed_bitstring(length: int, number: int) -> str: class PhaseEstimatorResult(AlgorithmResult): """Phase Estimator Result.""" - @property + @property # type: ignore @abstractmethod def phase(self) -> float: r"""Return the estimated phase as a number in :math:`[0.0, 1.0)`. diff --git a/qiskit/algorithms/variational_algorithm.py b/qiskit/algorithms/variational_algorithm.py index fc05d28af090..0f1661b1a35e 100644 --- a/qiskit/algorithms/variational_algorithm.py +++ b/qiskit/algorithms/variational_algorithm.py @@ -39,13 +39,13 @@ class VariationalAlgorithm(ABC): """The Variational Algorithm Base Class.""" - @property + @property # type: ignore @abstractmethod def initial_point(self) -> Optional[np.ndarray]: """Returns initial point.""" pass - @initial_point.setter + @initial_point.setter # type: ignore @abstractmethod def initial_point(self, initial_point: Optional[np.ndarray]) -> None: """Sets initial point.""" @@ -57,11 +57,11 @@ class VariationalResult(AlgorithmResult): def __init__(self) -> None: super().__init__() - self._optimizer_evals = None - self._optimizer_time = None - self._optimal_value = None - self._optimal_point = None - self._optimal_parameters = None + self._optimizer_evals: int | None = None + self._optimizer_time: float | None = None + self._optimal_value: float | None = None + self._optimal_point: np.ndarray | None = None + self._optimal_parameters: Dict | None = None self._optimizer_result = None self._optimal_circuit = None