classiq 0.52.0__py3-none-any.whl → 0.54.0__py3-none-any.whl

classiq/qmod/builtins/functions/standard_gates.py

@@ -405,7 +405,7 @@ def RZZ(theta: CReal, target: QArray[QBit, Literal[2]]) -> None:
 
 
 @qfunc(external=True)
-def CH(control: QBit, target: QBit) -> None:
+def CH(ctrl: QBit, target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -423,7 +423,7 @@ def CH(control: QBit, target: QBit) -> None:
     $$
 
     Args:
-        control: The control qubit.
+        ctrl: The control qubit.
         target: The qubit to apply the Hadamard gate on.
 
     Link: [Reference Manual](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/core-library-functions/standard_gates/standard_gates/)
@@ -432,7 +432,7 @@ def CH(control: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CX(control: QBit, target: QBit) -> None:
+def CX(ctrl: QBit, target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -450,7 +450,7 @@ def CX(control: QBit, target: QBit) -> None:
     $$
 
     Args:
-        control: The control qubit.
+        ctrl: The control qubit.
         target: The qubit to apply the Pauli-X gate on.
 
     Link: [Reference Manual](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/core-library-functions/standard_gates/standard_gates/)
@@ -459,7 +459,7 @@ def CX(control: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CY(control: QBit, target: QBit) -> None:
+def CY(ctrl: QBit, target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -477,7 +477,7 @@ def CY(control: QBit, target: QBit) -> None:
     $$
 
     Args:
-        control: The control qubit.
+        ctrl: The control qubit.
         target: The qubit to apply the Pauli-Y gate on.
 
     Link: [Reference Manual](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/core-library-functions/standard_gates/standard_gates/)
@@ -486,7 +486,7 @@ def CY(control: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CZ(control: QBit, target: QBit) -> None:
+def CZ(ctrl: QBit, target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -504,7 +504,7 @@ def CZ(control: QBit, target: QBit) -> None:
     $$
 
     Args:
-        control: The control qubit.
+        ctrl: The control qubit.
         target: The qubit to apply the Pauli-Z gate on.
 
     Link: [Reference Manual](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/core-library-functions/standard_gates/standard_gates/)
@@ -513,7 +513,7 @@ def CZ(control: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CRX(theta: CReal, control: QBit, target: QBit) -> None:
+def CRX(theta: CReal, ctrl: QBit, target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -532,7 +532,7 @@ def CRX(theta: CReal, control: QBit, target: QBit) -> None:
 
     Args:
         theta: The rotation angle in radians.
-        control: The control qubit.
+        ctrl: The control qubit.
         target: The qubit to apply the RX gate on.
 
     Link: [Reference Manual](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/core-library-functions/standard_gates/standard_gates/)
@@ -541,7 +541,7 @@ def CRX(theta: CReal, control: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CRY(theta: CReal, control: QBit, target: QBit) -> None:
+def CRY(theta: CReal, ctrl: QBit, target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -560,7 +560,7 @@ def CRY(theta: CReal, control: QBit, target: QBit) -> None:
 
     Args:
         theta (CReal): The rotation angle in radians.
-        control (QBit): The control qubit.
+        ctrl (QBit): The control qubit.
         target (QBit): The qubit to apply the RY gate on.
 
     Link: [Reference Manual](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/core-library-functions/standard_gates/standard_gates/)
@@ -569,7 +569,7 @@ def CRY(theta: CReal, control: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CRZ(theta: CReal, control: QBit, target: QBit) -> None:
+def CRZ(theta: CReal, ctrl: QBit, target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -588,7 +588,7 @@ def CRZ(theta: CReal, control: QBit, target: QBit) -> None:
 
     Args:
         theta (CReal): The rotation angle in radians.
-        control (QBit): The control qubit.
+        ctrl (QBit): The control qubit.
         target (QBit): The qubit to apply the RZ gate on.
 
     Link: [Reference Manual](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/core-library-functions/standard_gates/standard_gates/)
@@ -597,7 +597,7 @@ def CRZ(theta: CReal, control: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CPHASE(theta: CReal, control: QBit, target: QBit) -> None:
+def CPHASE(theta: CReal, ctrl: QBit, target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -616,7 +616,7 @@ def CPHASE(theta: CReal, control: QBit, target: QBit) -> None:
 
     Args:
         theta (CReal): The rotation angle in radians.
-        control (QBit): The control qubit.
+        ctrl (QBit): The control qubit.
         target (QBit): The qubit to apply the PHASE gate on.
 
     Link: [Reference Manual](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/core-library-functions/standard_gates/standard_gates/)
@@ -707,7 +707,7 @@ def U(theta: CReal, phi: CReal, lam: CReal, gam: CReal, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CCX(control: QArray[QBit, Literal[2]], target: QBit) -> None:
+def CCX(ctrl: QArray[QBit, Literal[2]], target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -731,7 +731,7 @@ def CCX(control: QArray[QBit, Literal[2]], target: QBit) -> None:
     More information can be found on [Wikipedia](https://en.wikipedia.org/wiki/Toffoli_gate).
 
     Args:
-        control (QArray[QBit, Literal[2]]): The control qubits.
+        ctrl (QArray[QBit, Literal[2]]): The control qubits.
         target (QBit): The qubit to apply the conditioned Pauli-X gate on.
 
     Link: [Reference Manual](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/core-library-functions/standard_gates/standard_gates/)

classiq/qmod/builtins/functions/state_preparation.py

@@ -1,8 +1,24 @@
 from typing import Literal
 
-from classiq.qmod.cparam import CArray, CBool, CInt, CReal
+from classiq.qmod.builtins.functions.arithmetic import modular_increment
+from classiq.qmod.builtins.functions.standard_gates import CX, IDENTITY, RY, H, X
+from classiq.qmod.builtins.functions.utility_functions import hadamard_transform
+from classiq.qmod.builtins.operations import control, if_, repeat
+from classiq.qmod.cparam import CBool, CInt
 from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_parameter import CArray, CReal
 from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum
+from classiq.qmod.symbolic import (
+    asin,
+    atan,
+    exp,
+    floor,
+    log,
+    max as qmax,
+    min as qmin,
+    pi,
+    sqrt,
+)
 
 
 @qfunc(external=True)
@@ -53,7 +69,7 @@ def allocate_num(
     Further reading is available on the [reference manual](https://docs.classiq.io/latest/reference-manual/qmod/language-reference/quantum-types#allocate-num)
 
     """
-    pass
+    allocate(num_qubits, out)
 
 
 @qfunc(external=True)
@@ -178,11 +194,31 @@ def inplace_prepare_amplitudes(
     pass
 
 
+def prepare_uniform_trimmed_state_apply_rotation(
+    size_lsb: CInt, lsbs_val: CInt, rotation_var: QBit
+) -> None:
+    # max hold for the case where the value is on the left side
+    # the fraction in the sqrt is the wanted amount of probability
+    # in the left side divided by the total amount
+    RY(
+        -2 * (asin(sqrt(qmin((2 ** (size_lsb)) / lsbs_val, 1))) + pi / 4) + pi,
+        rotation_var,
+    )
+
+
 @qfunc(external=True)
 def _prepare_uniform_trimmed_state_step(
     size_lsb: CInt, ctrl_val: CInt, lsbs_val: CInt, ctrl_var: QNum, rotation_var: QBit
 ) -> None:
-    pass
+    if_(
+        lsbs_val != 0,  # stop condition
+        lambda: control(
+            ctrl_var == ctrl_val,
+            lambda: prepare_uniform_trimmed_state_apply_rotation(
+                size_lsb, lsbs_val, rotation_var
+            ),
+        ),
+    )
 
 
 @qfunc(external=True)
@@ -207,7 +243,28 @@ def prepare_uniform_trimmed_state(m: CInt, q: QArray[QBit]) -> None:
         1. If the output variable has been declared with a specific number of qubits, it must match the number of allocated qubits.
         2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
     """
-    pass
+    hadamard_transform(q)
+
+    if_(
+        m < 2**q.len,
+        # initial step without control
+        lambda: prepare_uniform_trimmed_state_apply_rotation(
+            q.len - 1,  # type:ignore[arg-type]
+            m,
+            q[q.len - 1],
+        ),
+    )
+
+    repeat(
+        qmax(q.len - 1, 0),
+        lambda i: _prepare_uniform_trimmed_state_step(
+            q.len - i - 2,
+            floor(m / (2 ** (q.len - i - 1))),
+            m % (2 ** (q.len - i - 1)),
+            q[q.len - i - 1 : q.len],
+            q[q.len - i - 2],
+        ),
+    )
 
 
 @qfunc(external=True)
@@ -232,7 +289,8 @@ def prepare_uniform_interval_state(start: CInt, end: CInt, q: QArray[QBit]) -> N
         1. If the output variable has been declared with a specific number of qubits, it must match the number of allocated qubits.
         2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
     """
-    pass
+    prepare_uniform_trimmed_state(end - start, q)
+    modular_increment(start, q)
 
 
 @qfunc(external=True)
@@ -251,7 +309,20 @@ def prepare_ghz_state(size: CInt, q: Output[QArray[QBit]]) -> None:
 
 
     """
-    pass
+
+    def inner_lop(step: CInt) -> None:
+        repeat(
+            count=2**step,
+            iteration=lambda control_index: if_(
+                condition=control_index + 2**step >= size,
+                then=lambda: IDENTITY(q[0]),
+                else_=lambda: CX(q[control_index], q[control_index + 2**step]),
+            ),
+        )
+
+    allocate(size, q)
+    H(q[0])
+    repeat(floor(log(size - 1, 2)) + 1, inner_lop)  # type:ignore[arg-type]
 
 
 @qfunc(external=True)
@@ -272,7 +343,7 @@ def prepare_exponential_state(rate: CInt, q: QArray[QBit]) -> None:
 
     Further reading is available on the [reference manual](https://docs.classiq.io/latest/explore/functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_exponential_state)
     """
-    pass
+    repeat(q.len, lambda i: RY(2.0 * atan(exp((-rate * 2.0**i) / 2.0)), q[i]))
 
 
 @qfunc(external=True)
@@ -318,7 +389,10 @@ def prepare_bell_state(state_num: CInt, q: Output[QArray[QBit, Literal[2]]]) ->
 
 
     """
-    pass
+    allocate(2, q)
+    inplace_prepare_int(state_num, q)
+    H(q[0])
+    CX(q[0], q[1])
 
 
 @qfunc(external=True)
@@ -336,7 +410,14 @@ def inplace_prepare_int(value: CInt, target: QArray[QBit]) -> None:
     Note:
         If the value cannot fit into the quantum variable, it is truncated, i.e. treated as the value modulo $2^\\text{target.size}$.
     """
-    pass
+    repeat(
+        target.len,
+        lambda index: if_(
+            (floor(value / (2**index)) % 2) == 1,
+            lambda: X(target[index]),
+            lambda: IDENTITY(target[index]),
+        ),
+    )
 
 
 @qfunc(external=True)
@@ -357,4 +438,5 @@ def prepare_int(
     Note:
         If the output variable has been declared with a specific number of qubits, it must match the number of allocated qubits.
     """
-    pass
+    allocate(floor(log(value, 2)) + 1, out)
+    inplace_prepare_int(value, out)

classiq/qmod/builtins/functions/swap_test.py

@@ -1,3 +1,6 @@
+from classiq.qmod.builtins.functions.standard_gates import SWAP, H
+from classiq.qmod.builtins.functions.state_preparation import allocate
+from classiq.qmod.builtins.operations import control, repeat
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import Output, QArray, QBit
 
@@ -22,4 +25,7 @@ def swap_test(state1: QArray[QBit], state2: QArray[QBit], test: Output[QBit]) ->
     Example:
         Further reading in the Classiq library is found [here](https://docs.classiq.io/latest/explore/algorithms/swap_test/swap_test/).
     """
-    pass
+    allocate(1, test)
+    H(test)
+    control(test, lambda: repeat(state1.len, lambda i: SWAP(state1[i], state2[i])))
+    H(test)

classiq/qmod/builtins/functions/utility_functions.py

@@ -0,0 +1,43 @@
+from typing import Annotated
+
+from classiq.qmod.builtins.functions.standard_gates import H
+from classiq.qmod.builtins.operations import repeat
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_variable import QArray, QBit, QCallable
+
+
+@qfunc(external=True)
+def apply_to_all(
+    gate_operand: QCallable[Annotated[QBit, "target"]], target: QArray[QBit]
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies the single-qubit operand `gate_operand` to each qubit in the qubit
+    array `target`.
+
+    Args:
+        gate_operand: The single-qubit gate to apply to each qubit in the array.
+        target: The qubit array to apply the gate to.
+    """
+    repeat(target.len, lambda index: gate_operand(target[index]))
+
+
+@qfunc(external=True)
+def hadamard_transform(target: QArray[QBit]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies Hadamard transform to the target qubits.
+
+    Corresponds to the braket notation:
+
+    $$
+     H^{\\otimes n} |x\rangle = \frac{1}{\\sqrt{2^n}} \\sum_{y=0}^{2^n - 1} (-1)^{x \\cdot y} |y\rangle
+    $$
+
+    Args:
+        target:  qubits to apply to Hadamard transform to.
+
+    """
+    apply_to_all(H, target)

classiq/qmod/builtins/functions/variational.py

@@ -0,0 +1,53 @@
+from classiq.qmod.builtins.functions.standard_gates import RX, RY, RZ
+from classiq.qmod.builtins.functions.state_preparation import allocate
+from classiq.qmod.builtins.operations import repeat
+from classiq.qmod.cparam import CReal
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_parameter import CArray
+from classiq.qmod.qmod_variable import Output, QArray, QBit
+from classiq.qmod.symbolic import ceiling, floor, pi
+
+
+@qfunc(external=True)
+def encode_in_angle(data: CArray[CReal], qba: Output[QArray[QBit]]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Creates an angle encoding of n data points on n qubits.
+
+    Applies RY($\\pi$data[i]) on qba[i].
+
+    Args:
+        data: A classical array representing the data to encode.
+        qba: The array of qubits on which the data is encoded.
+    """
+    allocate(data.len, qba)
+    repeat(
+        count=data.len,
+        iteration=lambda index: RY(pi * data[index], qba[index]),
+    )
+
+
+@qfunc(external=True)
+def encode_on_bloch(data: CArray[CReal], qba: Output[QArray]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Creates a dense angle encoding of n data points on n//2 qubits.
+
+    Encodes pairs of data points on a Bloch sphere, via RX($\\pi$data[2*i])RZ($\\pi$data[2*i+1]) on qba[i].
+    If the length of the data is odd then RX($\\pi$data[i]) is applied on the last qubit.
+
+    Args:
+        data: A classical array representing the data to encode.
+        qba: The QArray of QBits on which the data is encoded.
+    """
+    allocate(ceiling(data.len / 2), qba)
+    repeat(
+        count=ceiling(data.len / 2),
+        iteration=lambda index: RX(pi * data[2 * index], qba[index]),
+    )
+    repeat(
+        count=floor(data.len / 2),
+        iteration=lambda index: RZ(pi * data[2 * index + 1], qba[index]),
+    )

classiq/qmod/builtins/operations.py

@@ -1,12 +1,11 @@
 import inspect
 import sys
+from collections.abc import Mapping
 from types import FrameType
 from typing import (
     Any,
     Callable,
     Final,
-    List,
-    Mapping,
     Union,
 )
 
@@ -48,8 +47,8 @@ _MISSING_VALUE: Final[int] = -1
 
 
 def bind(
-    source: Union[Input[QVar], List[Input[QVar]]],
-    destination: Union[Output[QVar], List[Output[QVar]]],
+    source: Union[Input[QVar], list[Input[QVar]]],
+    destination: Union[Output[QVar], list[Output[QVar]]],
 ) -> None:
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
@@ -311,5 +310,5 @@ __all__ = [
 ]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/qmod/cfunc.py

@@ -1,9 +1,9 @@
-from typing import Any, Callable, Dict, Optional, Union, overload
+from typing import Any, Callable, Optional, Union, overload
 
 from classiq.qmod.classical_function import CFunc
 
 
-def get_caller_locals() -> Dict[str, Any]:
+def get_caller_locals() -> dict[str, Any]:
     """Print the local variables in the caller's frame."""
     import inspect
 

classiq/qmod/classical_function.py

@@ -1,8 +1,7 @@
 import ast
 import inspect
-import sys
 from textwrap import dedent
-from typing import Any, Callable, Dict
+from typing import Any, Callable
 
 from classiq.interface.exceptions import ClassiqValueError
 
@@ -17,16 +16,13 @@ def _unparse_function_body(code: str, func: ast.FunctionDef) -> str:
 
 
 class CFunc:
-    def __init__(self, py_callable: Callable[[], None], caller_locals: Dict[str, Any]):
+    def __init__(self, py_callable: Callable[[], None], caller_locals: dict[str, Any]):
         code = dedent(inspect.getsource(py_callable))
         func = ast.parse(code).body[0]
         if not isinstance(func, ast.FunctionDef):
             raise ClassiqValueError("Use @cfunc to decorate a function")
         if len(func.args.args) > 0:
             raise ClassiqValueError("A @cfunc must receive no arguments")
-        if sys.version_info >= (3, 9):
-            self.code = "\n".join([ast.unparse(statement) for statement in func.body])
-        else:
-            self.code = _unparse_function_body(code, func)
+        self.code = "\n".join([ast.unparse(statement) for statement in func.body])
 
         self._caller_constants = caller_locals

classiq/qmod/create_model_function.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Dict, List, Optional, Union, cast
+from typing import TYPE_CHECKING, Optional, Union, cast
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
@@ -116,7 +116,7 @@ def _expand_generative_model(
 
 def _get_generative_functions(
     gen_main: QFunc, preferences: Optional[Preferences]
-) -> List[NativeFunctionDefinition]:
+) -> list[NativeFunctionDefinition]:
     # The Interpreter accepts a model and a list of generative functions.
     # Since the main function is generative, it can only be expanded using the
     # Interpreter.
@@ -154,10 +154,10 @@ def _get_wrapper_main(gen_main: QFunc, preferences: Optional[Preferences]) -> Mo
     )
 
 
-def _get_all_model_functions_as_generative_functions() -> List[GenerativeQFunc]:
+def _get_all_model_functions_as_generative_functions() -> list[GenerativeQFunc]:
+
     gen_functions = list(GEN_QFUNCS) + [
-        GenerativeQFunc(dec_func._py_callable, dec_func.func_decl)
-        for dec_func in DEC_QFUNCS
+        _get_gen_from_dec(dec_func) for dec_func in DEC_QFUNCS
     ]
     return [
         (
@@ -173,16 +173,27 @@ def _get_all_model_functions_as_generative_functions() -> List[GenerativeQFunc]:
     ]
 
 
+def _get_gen_from_dec(dec_func: QFunc) -> GenerativeQFunc:
+    synthesis_data = dec_func.synthesis_data
+    if synthesis_data is not None and synthesis_data.should_synthesize_separately:
+        raise ClassiqError(
+            """The model contains generative functions,
+            which cannot coexist with functions marked for separate synthesis"""
+        )
+    return GenerativeQFunc(dec_func._py_callable, dec_func.func_decl)
+
+
 def _interpret_generative_model(
-    gen_model: Model, gen_functions: List[GenerativeQFunc]
-) -> Dict[str, NativeFunctionDefinition]:
+    gen_model: Model, gen_functions: list[GenerativeQFunc]
+) -> dict[str, NativeFunctionDefinition]:
     resolve_function_calls(
         gen_model,
         {gen_func.func_decl.name: gen_func.func_decl for gen_func in gen_functions},
     )
     interpreter = Interpreter(gen_model, gen_functions, is_frontend=True)
     set_frontend_interpreter(interpreter)
-    functions_dict = nameables_to_dict(interpreter.expand().functions)
+    expand_model, _ = interpreter.expand()
+    functions_dict = nameables_to_dict(expand_model.functions)
 
     # Inline _gen_main call in main
     expanded_gen_main_name = cast(

classiq/qmod/declaration_inferrer.py

@@ -1,15 +1,12 @@
 import dataclasses
 import sys
+from collections.abc import Sequence
 from enum import EnumMeta
 from typing import (
     Any,
     Callable,
-    List,
     Literal,
     Optional,
-    Sequence,
-    Tuple,
-    Type,
     get_args,
     get_origin,
     overload,
@@ -91,7 +88,7 @@ def python_type_to_qmod(
 
 def _extract_port_decl(name: Optional[str], py_type: Any) -> AnonPortDeclaration:
     # FIXME: CAD-13409
-    qtype: Type[QVar] = QVar.from_type_hint(py_type)  # type:ignore[assignment]
+    qtype: type[QVar] = QVar.from_type_hint(py_type)  # type:ignore[assignment]
     direction = qtype.port_direction(py_type)
     if isinstance(py_type, _AnnotatedAlias):
         py_type = py_type.__args__[0]
@@ -128,7 +125,7 @@ def _extract_operand_decl(
     return param
 
 
-def _extract_operand_param(py_type: Any) -> Tuple[Optional[str], Any]:
+def _extract_operand_param(py_type: Any) -> tuple[Optional[str], Any]:
     if sys.version_info[0:2] < (3, 9) or get_origin(py_type) is not Annotated:
         return None, py_type
     args = get_args(py_type)
@@ -152,22 +149,22 @@ def _extract_operand_param(py_type: Any) -> Tuple[Optional[str], Any]:
 
 @overload
 def _extract_positional_args(
-    args: Sequence[Tuple[str, Any]], qmodule: Optional[ModelStateContainer]
+    args: Sequence[tuple[str, Any]], qmodule: Optional[ModelStateContainer]
 ) -> Sequence[PositionalArg]:
     pass
 
 
 @overload
 def _extract_positional_args(
-    args: Sequence[Tuple[Optional[str], Any]], qmodule: Optional[ModelStateContainer]
+    args: Sequence[tuple[Optional[str], Any]], qmodule: Optional[ModelStateContainer]
 ) -> Sequence[AnonPositionalArg]:
     pass
 
 
 def _extract_positional_args(
-    args: Sequence[Tuple[Optional[str], Any]], qmodule: Optional[ModelStateContainer]
+    args: Sequence[tuple[Optional[str], Any]], qmodule: Optional[ModelStateContainer]
 ) -> Sequence[AnonPositionalArg]:
-    result: List[AnonPositionalArg] = []
+    result: list[AnonPositionalArg] = []
     for name, py_type in args:
         if name == "return":
             continue

classiq/qmod/expression_query.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, List, Tuple
+from typing import TYPE_CHECKING
 
 from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
 from classiq.interface.generator.arith.number_utils import MAXIMAL_MACHINE_PRECISION
@@ -9,10 +9,10 @@ from classiq.qmod.symbolic_type import SymbolicTypes
 
 
 def get_expression_numeric_attributes(
-    vars: List[QNum],
+    vars: list[QNum],
     expr: SymbolicTypes,
     machine_precision: int = MAXIMAL_MACHINE_PRECISION,
-) -> Tuple[int, bool, int]:
+) -> tuple[int, bool, int]:
     """
     Computes and returns the numeric attributes of a given symbolic expression.
 

classiq/qmod/generative.py

@@ -1,5 +1,6 @@
+from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import TYPE_CHECKING, Any, Iterator, Optional
+from typing import TYPE_CHECKING, Any, Optional
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.expressions.expression import Expression