classiq 0.92.0__py3-none-any.whl → 0.99.0__py3-none-any.whl

classiq/applications/qsp/qsp.py

@@ -1,10 +1,9 @@
 import builtins
 import importlib.util
+from collections.abc import Callable
 from functools import wraps
-from typing import Callable, Optional
 
 import numpy as np
-from matplotlib import pyplot as plt
 from numpy.polynomial import Chebyshev, Polynomial
 from numpy.polynomial.chebyshev import cheb2poly, poly2cheb
 
@@ -42,7 +41,7 @@ def _pyqsp_get_phases(
 
     parity = (len(poly_coeffs) + 1) % 2
     reduced_coefs = poly_coeffs[parity::2]
-    phases, err, tot_iter, opt = newton_solver(reduced_coefs, parity, crit=tol)
+    _phases, err, _tot_iter, opt = newton_solver(reduced_coefs, parity, crit=tol)
     return opt.full_phases, err
 
 
@@ -51,7 +50,7 @@ def qsvt_phases(
 ) -> np.ndarray:
     r"""
     Get QSVT phases that will generate the given Chebyshev polynomial.
-    The phases are ready to be used in `qsvt` and `qsvt_lcu` functions in the classiq library. The convetion
+    The phases are ready to be used in `qsvt` and `qsvt_lcu` functions in the classiq library. The convention
     is the reflection signal operator, and the measurement basis is the hadamard basis (see https://arxiv.org/abs/2105.02859
     APPENDIX A.).
     The current implementation is using the pyqsp package, based on techniques in https://arxiv.org/abs/2003.02831.
@@ -119,13 +118,15 @@ def qsvt_phases(
 
 def _plot_qsp_approx(
     poly_cheb: np.ndarray,
-    f_target: Callable[[np.ndarray], np.ndarray],
+    f_target: Callable[[float], complex],
     interval: tuple[float, float] = (-1, 1),
 ) -> None:
+    from matplotlib import pyplot as plt
+
     grid_full = np.linspace(-1, 1, 3000)
     grid_interval = np.linspace(interval[0], interval[1], 3000)
 
-    y_target = f_target(grid_interval)
+    y_target = np.vectorize(f_target, otypes=[float])(grid_interval)
     y_approx = np.polynomial.Chebyshev(poly_cheb)(grid_full)
 
     # Plot
@@ -152,12 +153,12 @@ def _plot_qsp_approx(
 
 
 def qsp_approximate(
-    f_target: Callable[[np.ndarray], np.ndarray],
+    f_target: Callable[[float], complex],
     degree: int,
-    parity: Optional[int] = None,
+    parity: int | None = None,
     interval: tuple[float, float] = (-1, 1),
     bound: float = 0.99,
-    num_grid_points: Optional[int] = None,
+    num_grid_points: int | None = None,
     plot: bool = False,
 ) -> tuple[np.ndarray, float]:
     """
@@ -192,7 +193,8 @@ def qsp_approximate(
     # Select grid points for the objective in [w_min, w_max]
     xj_obj = xj_full[(xj_full >= interval[0]) & (xj_full <= interval[1])]
 
-    yj_obj = f_target(xj_obj)
+    yj_obj = np.vectorize(f_target, otypes=[float])(xj_obj)
+
     # heuristic verification
     bound = min(1, bound)
     assert (
@@ -313,7 +315,7 @@ def gqsp_phases(
     - Laurent polynomials are supported by degree shifting. If
       P(z) = sum_{k=m}^n c_k * z^k with m < 0, the phases correspond to the
       degree-shifted polynomial z^{-m} * P(z) (so the minimal degree is zero).
-    - The phase finiding works in the monomial basis. If the a Chebyshev basis polynomial is provided,
+    - The phase finiding works in the monomial basis. If a Chebyshev basis polynomial is provided,
       it will be converted to the monomial basis (and introduce an additional overhead).
 
     Args:
@@ -364,3 +366,229 @@ def gqsp_phases(
             s = np.array([s[0][1 : i + 1], s[1][:i]])
 
     return thetas, phis, lambdas
+
+
+def poly_jacobi_anger_cos(degree: int, t: float) -> np.ndarray:
+    r"""
+    Gets the Chebyshev polynomial coefficients approximating cos(t*x) using the Jacobi-Anger expansion.
+    $$\cos(xt) = J_0(t) + 2\sum_{k=1}^{d/2} (-1)^k J_{2k}(t)\, T_{2k}(x) $$
+
+    Args:
+        degree: the degree of the approximating polynomial.
+        t: the parameter in cos(t*x). Can be negative.
+    Returns:
+        coeffs: The Chebyshev approximating coefficients.
+    """
+    from scipy.special import jv
+
+    coeffs = np.zeros(degree + 1 if degree % 2 == 0 else degree)
+    for k in range(degree // 2 + 1):
+        coeffs[2 * k] = (2 if k > 0 else 1) * (-1) ** k * jv(2 * k, t)
+
+    return coeffs
+
+
+def poly_jacobi_anger_sin(degree: int, t: float) -> np.ndarray:
+    r"""
+    Gets the Chebyshev polynomial coefficients approximating sin(t*x) using the Jacobi-Anger expansion.
+    $$\sin(xt) = 2\sum_{k=0}^{d/2} (-1)^k J_{2k+1}(t)\, T_{2k+1}(x)$$
+
+    Args:
+        degree: the degree of the approximating polynomial.
+        t: the parameter in sin(t*x).
+    Returns:
+        coeffs: The Chebyshev approximating coefficients.
+    """
+    from scipy.special import jv
+
+    coeffs = np.zeros(degree + 1 if degree % 2 == 1 else degree)
+    for k in range(len(coeffs) // 2):
+        idx = 2 * k + 1
+        coeffs[idx] = 2 * (-1) ** k * jv(idx, t)
+    return coeffs
+
+
+def poly_jacobi_anger_exp_sin(degree: int, t: float) -> np.ndarray:
+    r"""
+    Gets the Chebyshev polynomial coefficients approximating exp(i*t*sin(x)) using the Jacobi-Anger expansion:
+    $$e^{it\sin(x)} = \sum_{k=-d}^{d} J_{k}(t) e^{ikx}$$
+
+    Args:
+        degree: the maximum degree of the approximating polynomial (negative and positive).
+        t: the parameter in exp(i*t*sin(x)).
+    Returns:
+        coeffs: The approximating coefficients in monomial basis, starting from the negative ones to the positive ones (length is 2*degree+1).
+    """
+    from scipy.special import jv
+
+    coeffs = [jv(k, t) for k in range(-degree, degree + 1)]
+    return np.array(coeffs)
+
+
+def poly_jacobi_anger_exp_cos(degree: int, t: float) -> np.ndarray:
+    r"""
+    Gets the Chebyshev polynomial coefficients approximating exp(i*t*cos(x)) using the Jacobi-Anger expansion:
+    $$e^{it\cos(x)} = \sum_{k=-d}^{d} i^k J_{k}(t) e^{ikx}$$
+
+    Args:
+        degree: the maximum degree of the approximating polynomial (negative and positive).
+        t: the parameter in exp(i*t*cos(x)).
+    Returns:
+        coeffs: The approximating coefficients in monomial basis, starting from the negative ones to the positive ones (length is 2*degree+1).
+    """
+    from scipy.special import jv
+
+    coeffs = [jv(k, t) * (1j**k) for k in range(-degree, degree + 1)]
+    return np.array(coeffs)
+
+
+def poly_jacobi_anger_degree(eps: float, t: float) -> int:
+    r"""
+    Get needed degree based on the maximum allowed uniform error on the interval [-1, 1]
+    for the Jacobi-Anger approximation. relevant for all poly_*_jacobi_anger functions.
+    Args:
+        eps: maximum allowed uniform error
+        t: the parameter in exp(i*t*cos(x))\exp(i*t*sin(x))\cos(t*x)\sin(t*x)
+    Returns:
+        degree: the minimal degree such that the polynomial approximation
+                using Jacobi-Anger expansion is within eps uniform error. relevant
+    """
+    # based on the approximation in https://arxiv.org/pdf/1806.01838 eq. (56)
+    from scipy.optimize import fsolve
+
+    deg = np.ceil(
+        fsolve(lambda r: (np.e * np.abs(t) / (2 * r)) ** r - 4 / 5 * eps, t)[0]
+    )
+    return int(max(deg, 1) + 1)
+
+
+def poly_jacobi_anger_error(degree: int, t: float) -> float:
+    r"""
+    Get the uniform error on the interval [-1, 1] for the Jacobi-Anger approximation,
+    based on the truncation degree. Relevant for all poly_*_jacobi_anger functions.
+    Args:
+        degree: truncation maximal degree
+        t: the parameter in exp(i*t*cos(x))\exp(i*t*sin(x))\cos(t*x)\sin(t*x)
+    Returns:
+        eps: a bound on the approximation uniform error
+    """
+    # based on the approximation in https://arxiv.org/pdf/1806.01838 eq. (56)
+    eps = 5 / 4 * (np.e * np.abs(t) / (2 * degree)) ** degree
+    return eps
+
+
+def poly_inversion(degree: int, kappa: float) -> tuple[np.ndarray, float]:
+    """
+    Gets the Chebyshev odd polynomial coefficients approximating 1/x on [1/kappa, 1] and bounded by 1 in magnitude on [-1, 1].
+    Based on the paper https://arxiv.org/pdf/2507.15537.
+
+    Note: To be used within the QSVT framework, the polynomial should be scaled to be bounded by 1 on [-1, 1].
+          The maximum absolute value of the returned polynomial on [-1, 1] can be larger than kappa, so the user
+          should use the returned max_value to scale down the polynomial accordingly.
+
+    Args:
+        degree: The degree of the approximating polynomial.
+        kappa: The number defining the interval [1/kappa, 1], usually represents the condition number in the setting of matrix inversion.
+
+    Returns:
+        coeffs: The Chebyshev polynomial coefficients approximating 1/x on [1/kappa, 1]
+                using the optimal polynomial of given degree.
+        max_value: An upper bound on the maximum absolute value of the polynomial on [-1, 1]. The value
+                   can be used to scale down the polynomial for the usage within QSVT.
+    """
+
+    def _evaluate_l_n(x: np.ndarray, n: int, a: float) -> np.ndarray:
+        """
+        L_n(x; a) = 2^{-(n-1)} [ T_n(x) + ((1-a)/(1+a)) T_{n-1}(x)]. (eq. 6)
+        """
+        x = np.asarray(x, dtype=float)
+        assert n >= 1, "n must be >= 1"
+        assert 0.0 < a < 1.0, "1/kappa must be in (0, 1)"
+
+        alpha = (1 + a) / (2 * (1 - a))
+        l1 = (x + (1 - a) / (1 + a)) / alpha
+        l2 = (x**2 + (1 - a) / (1 + a) * x / 2 - 1 / 2) / alpha**2
+        if n == 1:
+            return l1
+        for _ in range(3, n + 1):
+            l1, l2 = l2, x * l2 / alpha - l1 / (4 * alpha**2)
+        return l2
+
+    def _substitute_x(x: np.ndarray, a: float) -> np.ndarray:
+        """
+        helper function for the variable substitution in eq. (5).
+        """
+        return (2.0 * x * x - (1.0 + a * a)) / (1.0 - a * a)
+
+    def _evaluate_p(x: np.ndarray, d: int, a: float) -> np.ndarray:
+        """
+        Evaluate P_{2n-1}(x; a) with d odd, n=(d+1)//2.
+        Uses Eq. (5) with L_n from Eq. (6).
+        """
+        n = (d + 1) // 2
+        x = np.asarray(x, dtype=float)
+
+        # main branch
+        l_n = _evaluate_l_n(_substitute_x(x, a), n, a)
+        l_0 = _evaluate_l_n(_substitute_x(0.0, a), n, a)  # type: ignore[arg-type]
+        return (1.0 - (l_n / l_0)) / x
+
+    a = 1 / kappa
+    assert degree % 2 == 1, "degree must be odd"
+
+    coeffs = np.polynomial.chebyshev.chebinterpolate(
+        _evaluate_p, degree, args=(degree, a)
+    )
+    # enforce odd parity numerically:
+    coeffs[0::2] = 0.0
+
+    # calculate maximum value on [-1, 1]:
+    sampling_ratio = 25
+    grid = np.linspace(0, 1, degree * 25)
+    max_sampled = np.max(np.abs(np.polynomial.chebyshev.Chebyshev(coeffs)(grid)))
+    max_value = (
+        max_sampled * 1 / (np.cos(np.pi / (4 * sampling_ratio)))
+    )  # according to (25) in the paper
+
+    return coeffs, max_value
+
+
+def poly_inversion_degree(eps: float, kappa: float) -> int:
+    """
+    Get the needed degree based on the target uniform error on the interval [1/kappa, 1],
+    for the polynomial approximation of 1/x using the function poly_inversion.
+    Based on the paper https://arxiv.org/pdf/2507.15537.
+
+    Args:
+        eps: The target uniform approximation error.
+        kappa: The number defining the interval [1/kappa, 1], usually represents the condition number in the setting of matrix inversion.
+    Returns:
+        degree: The minimal degree such that the polynomial approximation of 1/x on [1/kappa, 1]
+                is within eps uniform error.
+    """
+    a = 1 / kappa
+    n = int(
+        np.ceil(
+            (np.log(1 / eps) + np.log(1 / a) + np.log(1 + a))
+            / np.log((1 + a) / (1 - a))
+        )
+    )
+    return 2 * n - 1
+
+
+def poly_inversion_error(degree: int, kappa: float) -> float:
+    """
+    Calculates uniform error on the interval [1/kappa, 1] for the polynomial
+    approximation of 1/x given by poly_inversion.
+    Based on the paper https://arxiv.org/pdf/2507.15537
+
+    Args:
+        degree: Inversion polynomial degree.
+        kappa: The number defining the interval [1/kappa, 1], usually represents the condition number in the setting of matrix inversion.
+
+    Returns:
+        eps: Uniform approximation error on [1/kappa, 1].
+    """
+    a = 1 / kappa
+    n = (degree + 1) // 2
+    return (1 - a) ** n / (a * (1 + a) ** (n - 1))

classiq/applications/qsvm/qsvm_data_generation.py

@@ -1,6 +1,5 @@
 import logging
 from collections import defaultdict
-from typing import Optional
 
 import numpy as np
 
@@ -14,7 +13,7 @@ def generate_data(
     range_min: float = 0,
     range_max: float = 2 * np.pi,
     std: float = 0.5,
-    sources: Optional[np.ndarray] = None,
+    sources: np.ndarray | None = None,
 ) -> dict[int, np.ndarray]:
     if sources is None:
         sources = np.random.uniform(

classiq/evaluators/classical_expression.py

@@ -17,9 +17,6 @@ from classiq.interface.generator.expressions.proxies.classical.utils import (
 from classiq.interface.generator.functions.classical_type import ClassicalArray, Integer
 
 from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
-from classiq.evaluators.qmod_expression_visitors.qmod_expression_bwc import (
-    QmodExpressionBwc,
-)
 from classiq.evaluators.qmod_expression_visitors.qmod_expression_evaluator import (
     evaluate_qmod_expression,
 )
@@ -59,7 +56,6 @@ def evaluate_classical_expression(expr: Expression, scope: Scope) -> Evaluated:
     if expr.is_evaluated():
         return Evaluated(value=expr.value.value)
     expr_ast = ast.parse(expr.expr)
-    expr_ast = QmodExpressionBwc().visit(expr_ast)
     expr_val = evaluate_qmod_expression(
         ast.unparse(expr_ast),
         classical_struct_declarations=list(QMODULE.type_decls.values()),

classiq/evaluators/parameter_types.py

@@ -25,7 +25,6 @@ from classiq.interface.generator.functions.port_declaration import (
 from classiq.interface.generator.functions.type_name import (
     TypeName,
 )
-from classiq.interface.helpers.backward_compatibility import zip_strict
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -80,7 +79,7 @@ def evaluate_parameter_types_from_args(
             f"{len(arguments)} were given"
         )
 
-    for parameter, argument in zip_strict(parameters, arguments, strict=True):
+    for parameter, argument in zip(parameters, arguments, strict=True):
         if isinstance(parameter, ClassicalParameterDeclaration):
             arg_val = argument.value
             if not isinstance(arg_val, QmodAnnotatedExpression):
@@ -88,11 +87,11 @@ def evaluate_parameter_types_from_args(
 
     evaluated_params = [
         _evaluate_type_from_arg(parameter, argument, closure)
-        for parameter, argument in zip_strict(parameters, arguments, strict=True)
+        for parameter, argument in zip(parameters, arguments, strict=True)
     ]
 
     parameter_names = {parameter.name for parameter in parameters}
-    for parameter, argument in zip_strict(parameters, arguments, strict=True):
+    for parameter, argument in zip(parameters, arguments, strict=True):
         if isinstance(parameter, QuantumOperandDeclaration):
             _update_operand_signature_environment(
                 argument.value, parameter_names, closure
@@ -134,6 +133,9 @@ def _evaluate_type_from_arg(
     # FIXME: Remove suzuki_trotter overloading (CLS-2912)
     if closure.name == "suzuki_trotter" and parameter.name == "pauli_operator":
         return parameter
+    # FIXME: Remove qdrift overloading (CLS-4347)
+    if closure.name == "qdrift" and parameter.name == "pauli_operator":
+        return parameter
     if isinstance(parameter, ClassicalParameterDeclaration):
         return _evaluate_classical_type_from_arg(parameter, argument, closure)
     if isinstance(parameter, PortDeclaration):
@@ -271,9 +273,9 @@ def _evaluate_op_type_from_arg(
 
 def _raise_argument_type_error(
     arg_val: Any,
-    arg_type: Union[QmodType, AnonQuantumOperandDeclaration],
+    arg_type: QmodType | AnonQuantumOperandDeclaration,
     param_name: str,
-    param_type: Union[QmodType, AnonQuantumOperandDeclaration],
+    param_type: QmodType | AnonQuantumOperandDeclaration,
 ) -> NoReturn:
     raise ClassiqExpansionError(
         f"Argument {str(arg_val)!r} of type "
@@ -377,15 +379,21 @@ def _eval_expr(
         val = get_sympy_val(val)
     if expected_type is int and isinstance(val, float) and int(val) == val:
         val = int(val)
-    if not isinstance(val, expected_type) and (
-        not isinstance(val, QmodAnnotatedExpression)
-        or not isinstance(val.get_type(val.root), expected_qmod_type)
-    ):
+
+    failing_type: str | None = None
+    if isinstance(val, QmodAnnotatedExpression):
+        val_type = val.get_type(val.root)
+        if not isinstance(val_type, expected_qmod_type):
+            failing_type = val_type.raw_qmod_type_name
+    elif not isinstance(val, expected_type):
+        failing_type = type(val).__name__
+    if failing_type is not None:
         raise ClassiqExpansionError(
             f"When inferring the type of parameter {param_name!r}: "
-            f"{type_name} {attr_name} must be {expected_qmod_type.__name__}, got "
-            f"{str(val)!r}"
+            f"{type_name} {attr_name} must be {expected_qmod_type().qmod_type_name}, "
+            f"got {str(val)!r} of type {failing_type}"
         )
+
     expr = Expression(expr=str(val))
     expr._evaluated_expr = EvaluatedExpression(value=val)
     return expr

classiq/evaluators/qmod_annotated_expression.py

@@ -2,7 +2,7 @@ import ast
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Union, cast
+from typing import Any, cast
 
 import sympy
 
@@ -98,26 +98,24 @@ class QmodAnnotatedExpression:
     def get_node(self, node_id: QmodExprNodeId) -> ast.AST:
         return self._node_mapping[node_id]
 
-    def set_value(self, node: Union[ast.AST, QmodExprNodeId], value: Any) -> None:
+    def set_value(self, node: ast.AST | QmodExprNodeId, value: Any) -> None:
         if self._locked:
             raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
             node = id(node)
         self._values[node] = value
 
-    def get_value(self, node: Union[ast.AST, QmodExprNodeId]) -> Any:
+    def get_value(self, node: ast.AST | QmodExprNodeId) -> Any:
         if isinstance(node, ast.AST):
             node = id(node)
         return self._values[node]
 
-    def has_value(self, node: Union[ast.AST, QmodExprNodeId]) -> bool:
+    def has_value(self, node: ast.AST | QmodExprNodeId) -> bool:
         if isinstance(node, ast.AST):
             node = id(node)
         return node in self._values
 
-    def set_type(
-        self, node: Union[ast.AST, QmodExprNodeId], qmod_type: QmodType
-    ) -> None:
+    def set_type(self, node: ast.AST | QmodExprNodeId, qmod_type: QmodType) -> None:
         if self._locked:
             raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
@@ -126,12 +124,12 @@ class QmodAnnotatedExpression:
             node = id(node)
         self._types[node] = qmod_type
 
-    def get_type(self, node: Union[ast.AST, QmodExprNodeId]) -> QmodType:
+    def get_type(self, node: ast.AST | QmodExprNodeId) -> QmodType:
         if isinstance(node, ast.AST):
             node = id(node)
         return self._types[node]
 
-    def get_quantum_type(self, node: Union[ast.AST, QmodExprNodeId]) -> QuantumType:
+    def get_quantum_type(self, node: ast.AST | QmodExprNodeId) -> QuantumType:
         if isinstance(node, ast.AST):
             node = id(node)
         qmod_type = self._types[node]
@@ -139,7 +137,7 @@ class QmodAnnotatedExpression:
             raise ClassiqInternalExpansionError
         return cast(QuantumType, qmod_type)
 
-    def get_classical_type(self, node: Union[ast.AST, QmodExprNodeId]) -> ClassicalType:
+    def get_classical_type(self, node: ast.AST | QmodExprNodeId) -> ClassicalType:
         if isinstance(node, ast.AST):
             node = id(node)
         qmod_type = self._types[node]
@@ -147,7 +145,7 @@ class QmodAnnotatedExpression:
             raise ClassiqInternalExpansionError
         return cast(ClassicalType, qmod_type)
 
-    def set_var(self, node: Union[ast.AST, QmodExprNodeId], var: HandleBinding) -> None:
+    def set_var(self, node: ast.AST | QmodExprNodeId, var: HandleBinding) -> None:
         if self._locked:
             raise ClassiqInternalExpansionError("QAE is locked")
         var = var.collapse()
@@ -158,25 +156,25 @@ class QmodAnnotatedExpression:
         else:
             self._quantum_vars[node] = var
 
-    def get_var(self, node: Union[ast.AST, QmodExprNodeId]) -> HandleBinding:
+    def get_var(self, node: ast.AST | QmodExprNodeId) -> HandleBinding:
         if isinstance(node, ast.AST):
             node = id(node)
         return (self._classical_vars | self._quantum_vars)[node]
 
-    def has_var(self, node: Union[ast.AST, QmodExprNodeId]) -> bool:
+    def has_var(self, node: ast.AST | QmodExprNodeId) -> bool:
         return self.has_classical_var(node) or self.has_quantum_var(node)
 
-    def has_classical_var(self, node: Union[ast.AST, QmodExprNodeId]) -> bool:
+    def has_classical_var(self, node: ast.AST | QmodExprNodeId) -> bool:
         if isinstance(node, ast.AST):
             node = id(node)
         return node in self._classical_vars
 
-    def has_quantum_var(self, node: Union[ast.AST, QmodExprNodeId]) -> bool:
+    def has_quantum_var(self, node: ast.AST | QmodExprNodeId) -> bool:
         if isinstance(node, ast.AST):
             node = id(node)
         return node in self._quantum_vars
 
-    def remove_var(self, node: Union[ast.AST, QmodExprNodeId]) -> None:
+    def remove_var(self, node: ast.AST | QmodExprNodeId) -> None:
         if self._locked:
             raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
@@ -188,9 +186,9 @@ class QmodAnnotatedExpression:
 
     def set_quantum_subscript(
         self,
-        node: Union[ast.AST, QmodExprNodeId],
-        value: Union[ast.AST, QmodExprNodeId],
-        index: Union[ast.AST, QmodExprNodeId],
+        node: ast.AST | QmodExprNodeId,
+        value: ast.AST | QmodExprNodeId,
+        index: ast.AST | QmodExprNodeId,
     ) -> None:
         if self._locked:
             raise ClassiqInternalExpansionError("QAE is locked")
@@ -204,11 +202,18 @@ class QmodAnnotatedExpression:
             value=value, index=index
         )
 
-    def has_quantum_subscript(self, node: Union[ast.AST, QmodExprNodeId]) -> bool:
+    def has_quantum_subscript(self, node: ast.AST | QmodExprNodeId) -> bool:
         if isinstance(node, ast.AST):
             node = id(node)
         return node in self._quantum_subscripts
 
+    def get_quantum_subcript(
+        self, node: ast.AST | QmodExprNodeId
+    ) -> QuantumSubscriptAnnotation:
+        if isinstance(node, ast.AST):
+            node = id(node)
+        return self._quantum_subscripts[node]
+
     def get_quantum_subscripts(
         self,
     ) -> Mapping[QmodExprNodeId, QuantumSubscriptAnnotation]:
@@ -216,7 +221,7 @@ class QmodAnnotatedExpression:
 
     def set_quantum_type_attr(
         self,
-        node: Union[ast.AST, QmodExprNodeId],
+        node: ast.AST | QmodExprNodeId,
         value: HandleBinding,
         attr: str,
     ) -> None:
@@ -228,7 +233,7 @@ class QmodAnnotatedExpression:
             value=value, attr=attr
         )
 
-    def has_quantum_type_attribute(self, node: Union[ast.AST, QmodExprNodeId]) -> bool:
+    def has_quantum_type_attribute(self, node: ast.AST | QmodExprNodeId) -> bool:
         if isinstance(node, ast.AST):
             node = id(node)
         return node in self._quantum_type_attrs
@@ -240,8 +245,8 @@ class QmodAnnotatedExpression:
 
     def set_concatenation(
         self,
-        node: Union[ast.AST, QmodExprNodeId],
-        elements: Sequence[Union[ast.AST, QmodExprNodeId]],
+        node: ast.AST | QmodExprNodeId,
+        elements: Sequence[ast.AST | QmodExprNodeId],
     ) -> None:
         if self._locked:
             raise ClassiqInternalExpansionError("QAE is locked")
@@ -257,7 +262,7 @@ class QmodAnnotatedExpression:
                 inlined_elements.extend(self._concatenations.pop(element).elements)
         self._concatenations[node] = ConcatenationAnnotation(elements=inlined_elements)
 
-    def has_concatenation(self, node: Union[ast.AST, QmodExprNodeId]) -> bool:
+    def has_concatenation(self, node: ast.AST | QmodExprNodeId) -> bool:
         if isinstance(node, ast.AST):
             node = id(node)
         return node in self._concatenations
@@ -271,7 +276,7 @@ class QmodAnnotatedExpression:
     def get_quantum_vars(self) -> Mapping[QmodExprNodeId, HandleBinding]:
         return self._quantum_vars
 
-    def clear_node_data(self, node: Union[ast.AST, QmodExprNodeId]) -> None:
+    def clear_node_data(self, node: ast.AST | QmodExprNodeId) -> None:
         if isinstance(node, ast.AST):
             node = id(node)
         self._node_mapping.pop(node, None)

classiq/evaluators/qmod_expression_visitors/qmod_expression_evaluator.py

@@ -1,7 +1,7 @@
 import ast
-from collections.abc import Mapping, Sequence
+from collections.abc import Callable, Mapping, Sequence
 from enum import IntEnum
-from typing import Any, Callable, Optional, cast
+from typing import Any, cast
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -79,13 +79,13 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
         *,
         treat_qnum_as_float: bool = False,
         machine_precision: int = DEFAULT_MACHINE_PRECISION,
-        classical_struct_declarations: Optional[Sequence[StructDeclaration]] = None,
-        enum_declarations: Optional[Sequence[EnumDeclaration]] = None,
-        classical_function_declarations: Optional[
+        classical_struct_declarations: Sequence[StructDeclaration] | None = None,
+        enum_declarations: Sequence[EnumDeclaration] | None = None,
+        classical_function_declarations: None | (
             Sequence[ClassicalFunctionDeclaration]
-        ] = None,
-        classical_function_callables: Optional[Mapping[str, Callable]] = None,
-        scope: Optional[Mapping[str, Any]] = None,
+        ) = None,
+        classical_function_callables: Mapping[str, Callable] | None = None,
+        scope: Mapping[str, Any] | None = None,
     ) -> None:
         self._expr_val = expr_val
         self._treat_qnum_as_float = treat_qnum_as_float
@@ -258,13 +258,13 @@ def evaluate_qmod_expression(
     *,
     treat_qnum_as_float: bool = False,
     machine_precision: int = DEFAULT_MACHINE_PRECISION,
-    classical_struct_declarations: Optional[Sequence[StructDeclaration]] = None,
-    enum_declarations: Optional[Sequence[EnumDeclaration]] = None,
-    classical_function_declarations: Optional[
+    classical_struct_declarations: Sequence[StructDeclaration] | None = None,
+    enum_declarations: Sequence[EnumDeclaration] | None = None,
+    classical_function_declarations: None | (
         Sequence[ClassicalFunctionDeclaration]
-    ] = None,
-    classical_function_callables: Optional[Mapping[str, Callable]] = None,
-    scope: Optional[Mapping[str, Any]] = None,
+    ) = None,
+    classical_function_callables: Mapping[str, Callable] | None = None,
+    scope: Mapping[str, Any] | None = None,
 ) -> QmodAnnotatedExpression:
     expr_ast = ast.parse(expr, mode="eval").body
     expr_value = QmodAnnotatedExpression(expr_ast)

classiq/evaluators/qmod_expression_visitors/qmod_expression_simplifier.py

@@ -1,5 +1,6 @@
 import ast
-from typing import Any, Callable, TypeVar, cast
+from collections.abc import Callable
+from typing import Any, TypeVar, cast
 
 import sympy