tequila-basic 1.9.9__py3-none-any.whl → 1.9.10__py3-none-any.whl

tequila/apps/robustness/interval.py

@@ -11,40 +11,44 @@ from tequila.circuit.noise import NoiseModel
 from tequila.hamiltonian import QubitHamiltonian
 from tequila.objective import Variable, ExpectationValue
 
-__all__ = ['robustness_interval',
-           'RobustnessInterval',
-           'SDPInterval',
-           'GramianExpectationBound',
-           'GramianEigenvalueInterval']
+__all__ = [
+    "robustness_interval",
+    "RobustnessInterval",
+    "SDPInterval",
+    "GramianExpectationBound",
+    "GramianEigenvalueInterval",
+]
 
-_EXPECTATION_ALIASES = ['expectation']
-_EIGENVALUE_ALIASES = ['eigenvalue', 'eigval']
+_EXPECTATION_ALIASES = ["expectation"]
+_EIGENVALUE_ALIASES = ["eigenvalue", "eigval"]
 
-_GRAMIAN_ALIASES = ['gramian', 'gram']
-_METHODS = ['sdp'] + ['best'] + _GRAMIAN_ALIASES
+_GRAMIAN_ALIASES = ["gramian", "gram"]
+_METHODS = ["sdp"] + ["best"] + _GRAMIAN_ALIASES
 
 
 class RobustnessInterval(ABC):
-    def __init__(self,
-                 fidelity: float,
-                 U: QCircuit = None,
-                 H: QubitHamiltonian = None,
-                 precomputed_stats: Dict[str, Union[List[List[float]], List[float], float]] = None):
+    def __init__(
+        self,
+        fidelity: float,
+        U: QCircuit = None,
+        H: QubitHamiltonian = None,
+        precomputed_stats: Dict[str, Union[List[List[float]], List[float], float]] = None,
+    ):
         self._U = U
         self._H = H
 
         # clean stats keys
-        self._precomputed_stats = {k.replace(' ', '_'): v for k, v in (precomputed_stats or {}).items()}
+        self._precomputed_stats = {k.replace(" ", "_"): v for k, v in (precomputed_stats or {}).items()}
 
-        self._pauligroups = self._precomputed_stats.get('pauligroups', [])
-        self._pauligroups_coeffs = self._precomputed_stats.get('pauligroups_coeffs')
-        self._pauligroups_eigenvalues = self._precomputed_stats.get('pauligroups_eigenvalues')
-        self._pauligroups_expectations = self._precomputed_stats.get('pauligroups_expectations')
-        self._pauligroups_variances = self._precomputed_stats.get('pauligroups_variances')
+        self._pauligroups = self._precomputed_stats.get("pauligroups", [])
+        self._pauligroups_coeffs = self._precomputed_stats.get("pauligroups_coeffs")
+        self._pauligroups_eigenvalues = self._precomputed_stats.get("pauligroups_eigenvalues")
+        self._pauligroups_expectations = self._precomputed_stats.get("pauligroups_expectations")
+        self._pauligroups_variances = self._precomputed_stats.get("pauligroups_variances")
 
-        self._hamiltonian_expectation = self._precomputed_stats.get('hamiltonian_expectations')
-        self._hamiltonian_variance = self._precomputed_stats.get('hamiltonian_variances')
-        self._normalization_constant = self._precomputed_stats.get('normalization_const')
+        self._hamiltonian_expectation = self._precomputed_stats.get("hamiltonian_expectations")
+        self._hamiltonian_variance = self._precomputed_stats.get("hamiltonian_variances")
+        self._normalization_constant = self._precomputed_stats.get("normalization_const")
 
         self._fidelity = fidelity
 
@@ -110,19 +114,19 @@ class RobustnessInterval(ABC):
 
 
 class SDPInterval(RobustnessInterval):
-
-    def __init__(self,
-                 fidelity: float,
-                 U: QCircuit = None,
-                 H: QubitHamiltonian = None,
-                 precomputed_stats: Dict[str, Union[List[List[float]], List[float], float]] = None,
-                 variables=None,
-                 samples=None,
-                 backend=None,
-                 device=None,
-                 noise=None,
-                 group_terms=True):
-
+    def __init__(
+        self,
+        fidelity: float,
+        U: QCircuit = None,
+        H: QubitHamiltonian = None,
+        precomputed_stats: Dict[str, Union[List[List[float]], List[float], float]] = None,
+        variables=None,
+        samples=None,
+        backend=None,
+        device=None,
+        noise=None,
+        group_terms=True,
+    ):
         super(SDPInterval, self).__init__(fidelity, U, H, precomputed_stats)
 
         self._compute_stats(variables, samples, backend, device, noise, group_terms)
@@ -132,32 +136,34 @@ class SDPInterval(RobustnessInterval):
 
     def _sanity_checks(self):
         if self._fidelity < 0 or self._fidelity > 1:
-            raise ValueError(f'encountered invalid fidelity; got {self._fidelity}, must be within [0, 1]!')
+            raise ValueError(f"encountered invalid fidelity; got {self._fidelity}, must be within [0, 1]!")
 
         # make sure that variance for each of the pauligroups is positive
         if self._pauligroups_variances is not None:
             for i, group_variance in enumerate(self._pauligroups_variances):
                 if group_variance <= -1e-6:
-                    raise ValueError(f'negative variance encountered: {group_variance}')
+                    raise ValueError(f"negative variance encountered: {group_variance}")
                 self._pauligroups_variances[i] = max(0.0, group_variance)
 
         # make sure that variance of Hamiltonian is positive
         if self._hamiltonian_variance is not None:
             if self._hamiltonian_variance <= -1e-6:
-                raise ValueError(f'negative variance encountered: v={self._hamiltonian_variance}')
+                raise ValueError(f"negative variance encountered: v={self._hamiltonian_variance}")
 
             self._hamiltonian_variance = max(0.0, float(self._hamiltonian_variance))
 
     def _compute_stats(self, variables, samples, backend, device, noise, group_terms):
-        if None not in [self._pauligroups,
-                        self._pauligroups_coeffs,
-                        self._pauligroups_expectations,
-                        self._pauligroups_eigenvalues]:
+        if None not in [
+            self._pauligroups,
+            self._pauligroups_coeffs,
+            self._pauligroups_expectations,
+            self._pauligroups_eigenvalues,
+        ]:
             # here stats have been provided; no need to recompute
             return
 
         if self._U is None or self._H is None:
-            raise ValueError('If U or H is not provided, you must provide precomputed_stats!')
+            raise ValueError("If U or H is not provided, you must provide precomputed_stats!")
 
         # compute expectation values
         if group_terms:
@@ -171,8 +177,11 @@ class SDPInterval(RobustnessInterval):
 
         # compute expectation values
         self._pauligroups_expectations = [
-            simulate(objective=objective, variables=variables, samples=samples, backend=backend, device=device,
-                     noise=noise) for objective in objectives]
+            simulate(
+                objective=objective, variables=variables, samples=samples, backend=backend, device=device, noise=noise
+            )
+            for objective in objectives
+        ]
 
         # compute eigenvalues for each term
         self._pauligroups_eigenvalues = [p_str.compute_eigenvalues() for p_str in self._pauligroups]
@@ -180,23 +189,26 @@ class SDPInterval(RobustnessInterval):
     def _compute_interval(self) -> Tuple[float, float]:
         lower_bound, upper_bound = 0.0, 0.0
 
-        for p_str, p_coeff, p_eigvals, p_expec in zip(self._pauligroups, self._pauligroups_coeffs,
-                                                      self._pauligroups_eigenvalues, self._pauligroups_expectations):
-
+        for p_str, p_coeff, p_eigvals, p_expec in zip(
+            self._pauligroups, self._pauligroups_coeffs, self._pauligroups_eigenvalues, self._pauligroups_expectations
+        ):
             min_eigval = min(p_eigvals)
             max_eigval = max(p_eigvals)
 
-            if str(p_str) == 'I' or len(p_str) == 0:
+            if str(p_str) == "I" or len(p_str) == 0:
                 pauli_lower_bound = pauli_upper_bound = 1.0
             else:
-                expec_normalized = np.clip(2 * (p_expec - min_eigval) / (max_eigval - min_eigval) - 1, -1, 1,
-                                           dtype=float)
+                expec_normalized = np.clip(
+                    2 * (p_expec - min_eigval) / (max_eigval - min_eigval) - 1, -1, 1, dtype=float
+                )
 
                 pauli_lower_bound = (max_eigval - min_eigval) / 2.0 * (
-                        1 + self._calc_lower_bound(expec_normalized, self.fidelity)) + min_eigval
+                    1 + self._calc_lower_bound(expec_normalized, self.fidelity)
+                ) + min_eigval
 
                 pauli_upper_bound = (max_eigval - min_eigval) / 2.0 * (
-                        1 + self._calc_upper_bound(expec_normalized, self.fidelity)) + min_eigval
+                    1 + self._calc_upper_bound(expec_normalized, self.fidelity)
+                ) + min_eigval
 
             lower_bound += p_coeff * pauli_lower_bound if p_coeff > 0 else p_coeff * pauli_upper_bound
             upper_bound += p_coeff * pauli_upper_bound if p_coeff > 0 else p_coeff * pauli_lower_bound
@@ -208,36 +220,37 @@ class SDPInterval(RobustnessInterval):
 
     @staticmethod
     def _calc_lower_bound(e, f):
-        assert -1.0 <= e <= 1.0, 'expectation not normalized to [-1, 1]'
+        assert -1.0 <= e <= 1.0, "expectation not normalized to [-1, 1]"
 
         if f < 0.5 * (1 - e):
             return -1.0
 
-        return (2 * f - 1) * e - 2 * np.sqrt(f * (1 - f) * (1 - e ** 2))
+        return (2 * f - 1) * e - 2 * np.sqrt(f * (1 - f) * (1 - e**2))
 
     @staticmethod
     def _calc_upper_bound(e, f):
-        assert -1.0 <= e <= 1.0, 'expectation not normalized to [-1, 1]'
+        assert -1.0 <= e <= 1.0, "expectation not normalized to [-1, 1]"
 
         if f < 0.5 * (1 + e):
             return 1.0
 
-        return (2.0 * f - 1.0) * e + 2.0 * np.sqrt(f * (1.0 - f) * (1.0 - e ** 2))
+        return (2.0 * f - 1.0) * e + 2.0 * np.sqrt(f * (1.0 - f) * (1.0 - e**2))
 
 
 class GramianExpectationBound(RobustnessInterval):
-
-    def __init__(self,
-                 fidelity: float,
-                 U: QCircuit = None,
-                 H: QubitHamiltonian = None,
-                 precomputed_stats: Dict[str, Union[List[List[float]], List[float], float]] = None,
-                 variables=None,
-                 samples=None,
-                 backend=None,
-                 device=None,
-                 noise=None,
-                 group_terms=True):
+    def __init__(
+        self,
+        fidelity: float,
+        U: QCircuit = None,
+        H: QubitHamiltonian = None,
+        precomputed_stats: Dict[str, Union[List[List[float]], List[float], float]] = None,
+        variables=None,
+        samples=None,
+        backend=None,
+        device=None,
+        noise=None,
+        group_terms=True,
+    ):
         super(GramianExpectationBound, self).__init__(fidelity, U, H, precomputed_stats)
 
         self._compute_stats(variables, samples, backend, device, noise, group_terms)
@@ -249,33 +262,35 @@ class GramianExpectationBound(RobustnessInterval):
 
     def _sanity_checks(self):
         if self._fidelity < 0 or self._fidelity > 1:
-            raise ValueError(f'encountered invalid fidelity; got {self._fidelity}, must be within [0, 1]!')
+            raise ValueError(f"encountered invalid fidelity; got {self._fidelity}, must be within [0, 1]!")
 
         # make sure that variance for each of the pauligroups is positive
         if self._pauligroups_variances is not None:
             for i, group_variance in enumerate(self._pauligroups_variances):
                 if group_variance <= -1e-6:
-                    raise ValueError(f'negative variance encountered: {group_variance}')
+                    raise ValueError(f"negative variance encountered: {group_variance}")
                 self._pauligroups_variances[i] = max(0.0, group_variance)
 
         # make sure that variance of Hamiltonian is positive
         if self._hamiltonian_variance is not None:
             if self._hamiltonian_variance <= -1e-6:
-                raise ValueError(f'negative variance encountered: v={self._hamiltonian_variance}')
+                raise ValueError(f"negative variance encountered: v={self._hamiltonian_variance}")
 
             self._hamiltonian_variance = max(0.0, float(self._hamiltonian_variance))
 
     def _compute_stats(self, variables, samples, backend, device, noise, group_terms):
-        if None not in [self._pauligroups,
-                        self._pauligroups_coeffs,
-                        self._pauligroups_expectations,
-                        self._pauligroups_variances,
-                        self._pauligroups_eigenvalues]:
+        if None not in [
+            self._pauligroups,
+            self._pauligroups_coeffs,
+            self._pauligroups_expectations,
+            self._pauligroups_variances,
+            self._pauligroups_eigenvalues,
+        ]:
             # here stats have been provided; no need to recompute
             return
 
         if self._U is None or self._H is None:
-            raise ValueError('If U or H is not provided, you must provide precomputed_stats!')
+            raise ValueError("If U or H is not provided, you must provide precomputed_stats!")
 
         if group_terms:
             # here we group pauli terms into groups of commuting terms
@@ -290,14 +305,18 @@ class GramianExpectationBound(RobustnessInterval):
             objectives = [ExpectationValue(U=self._U + group.U, H=group.H) for group in self._pauligroups]
             self._pauligroups_expectations = [
                 simulate(objective, variables=variables, samples=samples, backend=backend, device=device, noise=noise)
-                for objective in objectives]
+                for objective in objectives
+            ]
 
             # variance
-            objectives = [ExpectationValue(U=self._U + group.U, H=(group.H - e) ** 2) for group, e in
-                          zip(self._pauligroups, self._pauligroups_expectations)]
+            objectives = [
+                ExpectationValue(U=self._U + group.U, H=(group.H - e) ** 2)
+                for group, e in zip(self._pauligroups, self._pauligroups_expectations)
+            ]
             self._pauligroups_variances = [
                 simulate(objective, variables=variables, samples=samples, backend=backend, device=device, noise=noise)
-                for objective in objectives]
+                for objective in objectives
+            ]
 
         else:
             # here we compute stats for the entire hamiltonian and add a const s.t. it is ≥ 0
@@ -306,18 +325,21 @@ class GramianExpectationBound(RobustnessInterval):
             const_pauli_terms = [i for i, pstr in enumerate(pauli_strings) if len(pstr) == 0]
 
             self._normalization_constant = -np.sum([pauli_coeffs[i] for i in const_pauli_terms])
-            self._normalization_constant += np.sum([
-                np.abs(pauli_coeffs[i]) for i in set(range(len(pauli_coeffs))) - set(const_pauli_terms)])
+            self._normalization_constant += np.sum(
+                [np.abs(pauli_coeffs[i]) for i in set(range(len(pauli_coeffs))) - set(const_pauli_terms)]
+            )
 
             # compute expectation
             objective = ExpectationValue(U=self._U, H=self._H)
-            self._hamiltonian_expectation = simulate(objective, variables=variables, samples=samples, backend=backend,
-                                                     device=device, noise=noise)
+            self._hamiltonian_expectation = simulate(
+                objective, variables=variables, samples=samples, backend=backend, device=device, noise=noise
+            )
 
             # compute variance
             objective = ExpectationValue(U=self._U, H=(self._H - self._hamiltonian_expectation) ** 2)
-            self._hamiltonian_variance = simulate(objective, variables=variables, samples=samples, backend=backend,
-                                                  device=device, noise=noise)
+            self._hamiltonian_variance = simulate(
+                objective, variables=variables, samples=samples, backend=backend, device=device, noise=noise
+            )
 
     def _compute_interval(self, group_terms) -> float:
         if group_terms:
@@ -328,14 +350,16 @@ class GramianExpectationBound(RobustnessInterval):
 
     def _compute_bound_hamiltonian(self) -> float:
         bound = -self._normalization_constant + self._calc_lower_bound(
-            self._normalization_constant + self._hamiltonian_expectation, self._hamiltonian_variance, self.fidelity)
+            self._normalization_constant + self._hamiltonian_expectation, self._hamiltonian_variance, self.fidelity
+        )
         return bound
 
     def _compute_bound_grouped(self) -> float:
         bound = 0.0
 
-        for eigvals, expec, variance in zip(self._pauligroups_eigenvalues, self._pauligroups_expectations,
-                                            self._pauligroups_variances):
+        for eigvals, expec, variance in zip(
+            self._pauligroups_eigenvalues, self._pauligroups_expectations, self._pauligroups_variances
+        ):
             min_eigval = min(eigvals)
             expec_pos = np.clip(expec - min_eigval, 0, None, dtype=float)
             bound += min_eigval + self._calc_lower_bound(expec_pos, variance, self.fidelity)
@@ -358,11 +382,14 @@ class GramianExpectationBound(RobustnessInterval):
     def _calc_lower_bound(expectation, variance, fidelity):
         assert expectation >= 0
 
-        if fidelity / (1 - fidelity) < variance / (expectation ** 2):
+        if fidelity / (1 - fidelity) < variance / (expectation**2):
             return 0.0
 
-        return fidelity * expectation + (1 - fidelity) / expectation * variance - 2 * np.sqrt(
-            variance * fidelity * (1 - fidelity))
+        return (
+            fidelity * expectation
+            + (1 - fidelity) / expectation * variance
+            - 2 * np.sqrt(variance * fidelity * (1 - fidelity))
+        )
 
     @staticmethod
     def _calc_upper_bound():
@@ -370,17 +397,18 @@ class GramianExpectationBound(RobustnessInterval):
 
 
 class GramianEigenvalueInterval(RobustnessInterval):
-
-    def __init__(self,
-                 fidelity: float,
-                 U: QCircuit = None,
-                 H: QubitHamiltonian = None,
-                 precomputed_stats: Dict[str, Union[List[List[float]], List[float], float]] = None,
-                 variables=None,
-                 samples=None,
-                 backend=None,
-                 device=None,
-                 noise=None):
+    def __init__(
+        self,
+        fidelity: float,
+        U: QCircuit = None,
+        H: QubitHamiltonian = None,
+        precomputed_stats: Dict[str, Union[List[List[float]], List[float], float]] = None,
+        variables=None,
+        samples=None,
+        backend=None,
+        device=None,
+        noise=None,
+    ):
         super(GramianEigenvalueInterval, self).__init__(fidelity, U, H, precomputed_stats)
 
         self._compute_stats(variables, samples, backend, device, noise)
@@ -391,11 +419,11 @@ class GramianEigenvalueInterval(RobustnessInterval):
 
     def _sanity_checks(self):
         if self._fidelity < 0 or self._fidelity > 1:
-            raise ValueError(f'encountered invalid fidelity; got {self._fidelity}, must be within [0, 1]!')
+            raise ValueError(f"encountered invalid fidelity; got {self._fidelity}, must be within [0, 1]!")
 
         # make sure that variance of Hamiltonian is positive
         if self._hamiltonian_variance <= -1e-6:
-            raise ValueError(f'negative variance encountered: v={self._hamiltonian_variance}')
+            raise ValueError(f"negative variance encountered: v={self._hamiltonian_variance}")
 
         self._hamiltonian_variance = max(0.0, float(self._hamiltonian_variance))
 
@@ -405,17 +433,19 @@ class GramianEigenvalueInterval(RobustnessInterval):
             return
 
         if self._U is None or self._H is None:
-            raise ValueError('If U or H is not provided, you must provide precomputed_stats!')
+            raise ValueError("If U or H is not provided, you must provide precomputed_stats!")
 
         # compute expectation
         objective = ExpectationValue(U=self._U, H=self._H)
-        self._hamiltonian_expectation = simulate(objective, variables=variables, samples=samples, backend=backend,
-                                                 device=device, noise=noise)
+        self._hamiltonian_expectation = simulate(
+            objective, variables=variables, samples=samples, backend=backend, device=device, noise=noise
+        )
 
         # compute variance
         objective = ExpectationValue(U=self._U, H=(self._H - self._hamiltonian_expectation) ** 2)
-        self._hamiltonian_variance = simulate(objective, variables=variables, samples=samples, backend=backend,
-                                              device=device, noise=noise)
+        self._hamiltonian_variance = simulate(
+            objective, variables=variables, samples=samples, backend=backend, device=device, noise=noise
+        )
 
     def _compute_interval(self) -> Tuple[float, float]:
         lower_bound = self._calc_lower_bound(self._hamiltonian_expectation, self._hamiltonian_variance, self.fidelity)
@@ -437,19 +467,21 @@ class GramianEigenvalueInterval(RobustnessInterval):
         return expectation + np.sqrt(variance) * np.sqrt((1.0 - fidelity) / fidelity)
 
 
-def robustness_interval(U: QCircuit,
-                        H: QubitHamiltonian,
-                        fidelity: float,
-                        variables: Dict[Union[Variable, Hashable], RealNumber] = None,
-                        kind: str = 'expectation',
-                        method: str = 'best',
-                        group_terms: bool = True,
-                        samples: int = None,
-                        backend: str = None,
-                        noise: Union[str, NoiseModel] = None,
-                        device: str = None,
-                        return_object: bool = False) -> (float, float, float, Union[RobustnessInterval, None]):
-    """ calculate robustness intervals
+def robustness_interval(
+    U: QCircuit,
+    H: QubitHamiltonian,
+    fidelity: float,
+    variables: Dict[Union[Variable, Hashable], RealNumber] = None,
+    kind: str = "expectation",
+    method: str = "best",
+    group_terms: bool = True,
+    samples: int = None,
+    backend: str = None,
+    noise: Union[str, NoiseModel] = None,
+    device: str = None,
+    return_object: bool = False,
+) -> (float, float, float, Union[RobustnessInterval, None]):
+    """calculate robustness intervals
 
     Parameters
     ---------
@@ -488,39 +520,83 @@ def robustness_interval(U: QCircuit,
         expectation of H with U, and the upper bound.
 
     """
-    method = method.lower().replace('_', '').replace(' ', '')
-    kind = kind.lower().replace('_', '').replace(' ', '')
+    method = method.lower().replace("_", "").replace(" ", "")
+    kind = kind.lower().replace("_", "").replace(" ", "")
 
     if kind not in _EXPECTATION_ALIASES + _EIGENVALUE_ALIASES:
-        raise ValueError(f'unknown robustness interval type; got {kind}, '
-                         + f'must be one of {_EXPECTATION_ALIASES + _EIGENVALUE_ALIASES}')
+        raise ValueError(
+            f"unknown robustness interval type; got {kind}, "
+            + f"must be one of {_EXPECTATION_ALIASES + _EIGENVALUE_ALIASES}"
+        )
 
     if method not in _METHODS:
-        raise ValueError(f'unknown method; got {method}, must be one of {_METHODS}')
-
-    if method == 'sdp':
-        interval = SDPInterval(U=U, H=H, fidelity=fidelity, variables=variables, backend=backend, noise=noise,
-                               device=device, samples=samples, group_terms=group_terms)
+        raise ValueError(f"unknown method; got {method}, must be one of {_METHODS}")
+
+    if method == "sdp":
+        interval = SDPInterval(
+            U=U,
+            H=H,
+            fidelity=fidelity,
+            variables=variables,
+            backend=backend,
+            noise=noise,
+            device=device,
+            samples=samples,
+            group_terms=group_terms,
+        )
         return interval.interval, (interval if return_object else None)
 
     if method in _GRAMIAN_ALIASES:
-
         if kind in _EXPECTATION_ALIASES:
-            interval = GramianExpectationBound(U=U, H=H, fidelity=fidelity, variables=variables, backend=backend,
-                                               noise=noise, device=device, samples=samples, group_terms=group_terms)
+            interval = GramianExpectationBound(
+                U=U,
+                H=H,
+                fidelity=fidelity,
+                variables=variables,
+                backend=backend,
+                noise=noise,
+                device=device,
+                samples=samples,
+                group_terms=group_terms,
+            )
             return interval.interval, (interval if return_object else None)
 
         if kind in _EIGENVALUE_ALIASES:
-            interval = GramianEigenvalueInterval(U=U, H=H, fidelity=fidelity, variables=variables, backend=backend,
-                                                 noise=noise, device=device, samples=samples)
+            interval = GramianEigenvalueInterval(
+                U=U,
+                H=H,
+                fidelity=fidelity,
+                variables=variables,
+                backend=backend,
+                noise=noise,
+                device=device,
+                samples=samples,
+            )
             return interval.interval, (interval if return_object else None)
 
-    if method == 'best':
-        sdp_interval = SDPInterval(U=U, H=H, fidelity=fidelity, variables=variables, backend=backend, noise=noise,
-                                   device=device, samples=samples, group_terms=True)
-        gramian_exp_interval = GramianExpectationBound(U=U, H=H, fidelity=fidelity, variables=variables,
-                                                       backend=backend, noise=noise, device=device, samples=samples,
-                                                       group_terms=True)
+    if method == "best":
+        sdp_interval = SDPInterval(
+            U=U,
+            H=H,
+            fidelity=fidelity,
+            variables=variables,
+            backend=backend,
+            noise=noise,
+            device=device,
+            samples=samples,
+            group_terms=True,
+        )
+        gramian_exp_interval = GramianExpectationBound(
+            U=U,
+            H=H,
+            fidelity=fidelity,
+            variables=variables,
+            backend=backend,
+            noise=noise,
+            device=device,
+            samples=samples,
+            group_terms=True,
+        )
         if kind in _EXPECTATION_ALIASES:
             max_lower_bound = max([sdp_interval.lower_bound, gramian_exp_interval.lower_bound])
             min_upper_bound = sdp_interval.upper_bound
@@ -539,16 +615,22 @@ def robustness_interval(U: QCircuit,
 
         if kind in _EIGENVALUE_ALIASES:
             # reuse expectation and variance
-            gramian_eigv_interval = GramianEigenvalueInterval(U=U, H=H, fidelity=fidelity, variables=variables,
-                                                              backend=backend, noise=noise, device=device,
-                                                              samples=samples)
-
-            max_lower_bound = max([sdp_interval.lower_bound,
-                                   gramian_exp_interval.lower_bound,
-                                   gramian_eigv_interval.lower_bound])
-
-            min_upper_bound = min([sdp_interval.upper_bound,
-                                   gramian_eigv_interval.upper_bound])
+            gramian_eigv_interval = GramianEigenvalueInterval(
+                U=U,
+                H=H,
+                fidelity=fidelity,
+                variables=variables,
+                backend=backend,
+                noise=noise,
+                device=device,
+                samples=samples,
+            )
+
+            max_lower_bound = max(
+                [sdp_interval.lower_bound, gramian_exp_interval.lower_bound, gramian_eigv_interval.lower_bound]
+            )
+
+            min_upper_bound = min([sdp_interval.upper_bound, gramian_eigv_interval.upper_bound])
 
             interval = None
             if return_object: