classiq 0.37.1__py3-none-any.whl → 0.65.3__py3-none-any.whl

classiq/interface/generator/arith/unary_ops.py

@@ -1,43 +1,36 @@
-from __future__ import annotations
-
-import abc
-from typing import Iterable, Optional
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Final, Optional
 
 import pydantic
+from pydantic import ConfigDict
 
-from classiq.interface.generator.arith import number_utils
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.arith import argument_utils, number_utils
 from classiq.interface.generator.arith.arithmetic_operations import (
+    MODULO_WITH_FRACTION_PLACES_ERROR_MSG,
     ArithmeticOperationParams,
 )
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.function_params import get_zero_input_name
 
-UNARY_ARG_NAME: str = "arg"
+UNARY_ARG_NAME: Final[str] = "arg"
 
 
 class UnaryOpParams(ArithmeticOperationParams):
     arg: RegisterArithmeticInfo
     inplace: bool = False
 
-    @abc.abstractmethod
-    def _expected_result_size(self) -> pydantic.PositiveInt:
-        pass
-
-    def actual_result_size(self) -> int:
-        return self.output_size or self._expected_result_size()
-
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
-        return int(self.is_inplaced()) * max(
-            self.arg.size - self.actual_result_size(), 0
+        return int(self.is_inplaced()) * (
+            max(self.arg.integer_part_size - self.result_register.integer_part_size, 0)
+            + max(self.arg.fraction_places - self.result_register.fraction_places, 0)
         )
 
     def should_add_zero_inputs(self) -> bool:
-        return not self.is_inplaced() or self.should_add_zero_input_for_extension()
+        return not self.is_inplaced() or self.zero_input_for_extension() > 0
 
-    def should_add_zero_input_for_extension(
-        self, output_size: Optional[int] = None
-    ) -> bool:
-        return (output_size or self.result_register.size) > self.arg.size
+    def zero_input_for_extension(self) -> pydantic.NonNegativeInt:
+        return max(0, self.result_register.size - self.arg.size)
 
     def _create_ios(self) -> None:
         self._inputs = {UNARY_ARG_NAME: self.arg}
@@ -49,8 +42,8 @@ class UnaryOpParams(ArithmeticOperationParams):
             zero_input_register = self.result_register
             self._zero_inputs = {zero_input_name: zero_input_register}
             return
-        if self.should_add_zero_input_for_extension():
-            output_extension_size = self.result_register.size - self.arg.size
+        if self.zero_input_for_extension() > 0:
+            output_extension_size = self.zero_input_for_extension()
             self._create_zero_input_registers({zero_input_name: output_extension_size})
         if self.garbage_output_size() > 0:
             self._outputs[self.garbage_output_name] = RegisterArithmeticInfo(
@@ -60,62 +53,80 @@ class UnaryOpParams(ArithmeticOperationParams):
     def is_inplaced(self) -> bool:
         return self.inplace
 
-    def get_params_inplace_options(self) -> Iterable[UnaryOpParams]:
-        params_kwargs = self.copy().__dict__
+    def get_params_inplace_options(self) -> Iterable["UnaryOpParams"]:
+        params_kwargs = self.model_copy().model_dump()
         params_kwargs["inplace"] = True
         yield self.__class__(**params_kwargs)
 
-    class Config:
-        arbitrary_types_allowed = True
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
 
 class BitwiseInvert(UnaryOpParams):
     output_name = "inverted"
 
-    def _expected_result_size(self) -> pydantic.PositiveInt:
-        return self.arg.size
-
     def _get_result_register(self) -> RegisterArithmeticInfo:
+        eff_arg = argument_utils.limit_fraction_places(self.arg, self.machine_precision)
+        if TYPE_CHECKING:
+            assert isinstance(eff_arg, RegisterArithmeticInfo)
         return RegisterArithmeticInfo(
-            size=self.actual_result_size(),
-            fraction_places=self.arg.fraction_places,
-            is_signed=self.arg.is_signed and self._include_sign,
+            size=self.output_size or eff_arg.size,
+            fraction_places=eff_arg.fraction_places,
+            is_signed=eff_arg.is_signed and self._include_sign,
         )
 
 
 class Negation(UnaryOpParams):
+    bypass_bounds_validation: bool = pydantic.Field(
+        default=False
+    )  # True for efficient subtraction
     output_name = "negated"
 
-    def _expected_result_size(self) -> pydantic.PositiveInt:
-        if self.arg.size == 1:
+    @staticmethod
+    def _expected_result_size(arg: RegisterArithmeticInfo) -> pydantic.PositiveInt:
+        if arg.size == 1:
             return 1
-        return self.arg.fraction_places + number_utils.bounds_to_integer_part_size(
-            *(-bound for bound in self.arg.bounds)
+        return arg.fraction_places + number_utils.bounds_to_integer_part_size(
+            *(-bound for bound in arg.bounds)
         )
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        is_signed = max(self.arg.bounds) > 0 and self._include_sign
-        bounds = (-max(self.arg.bounds), -min(self.arg.bounds))
+        eff_arg = self.arg.limit_fraction_places(self.machine_precision)
+        is_signed = max(eff_arg.bounds) > 0 and self._include_sign
+        bounds = (-max(eff_arg.bounds), -min(eff_arg.bounds))
+        if self.output_size and not self.bypass_bounds_validation:
+            if eff_arg.fraction_places:
+                raise ValueError(MODULO_WITH_FRACTION_PLACES_ERROR_MSG)
+            max_bounds = RegisterArithmeticInfo.get_maximal_bounds(
+                size=self.output_size, is_signed=False, fraction_places=0
+            )
+            bounds = number_utils.bounds_cut(bounds, max_bounds)
         return RegisterArithmeticInfo(
-            size=self.actual_result_size(),
-            fraction_places=self.arg.fraction_places,
+            size=self.output_size or self._expected_result_size(eff_arg),
+            fraction_places=eff_arg.fraction_places,
             is_signed=is_signed,
-            bounds=bounds if (is_signed or min(bounds) >= 0) else None,
+            bypass_bounds_validation=self.bypass_bounds_validation,
+            bounds=bounds,
         )
 
+    def zero_input_for_extension(self) -> pydantic.NonNegativeInt:
+        eff_arg = self.arg.limit_fraction_places(self.machine_precision)
+        if (self.output_size or eff_arg.size) == 1:
+            return 0
+        return (
+            self.output_size or self._expected_result_size(self.arg)
+        ) - self.arg.size
+
 
 class Sign(UnaryOpParams):
     output_name = "sign"
 
-    @pydantic.validator("output_size")
+    @pydantic.field_validator("output_size")
+    @classmethod
     def _validate_output_size(
         cls, output_size: Optional[pydantic.PositiveInt]
     ) -> pydantic.PositiveInt:
         if output_size is not None and output_size != 1:
-            raise ValueError("Sign output size must be 1")
-        return 1
-
-    def _expected_result_size(self) -> pydantic.PositiveInt:
+            raise ClassiqValueError("Sign output size must be 1")
         return 1
 
     def _get_result_register(self) -> RegisterArithmeticInfo:

classiq/interface/generator/arith/uncomputation_methods.py

@@ -1,4 +1,4 @@
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
 
 
 class UncomputationMethods(StrEnum):

classiq/interface/generator/builtin_api_builder.py

@@ -1,19 +1,12 @@
-from typing import Any, Iterable
+from collections.abc import Iterable
+from typing import Any
 
 from classiq.interface.generator.functions.classical_function_declaration import (
     ClassicalFunctionDeclaration,
 )
-from classiq.interface.generator.types.struct_declaration import StructDeclaration
-from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
-)
 
 
 def populate_builtin_declarations(decls: Iterable[Any]) -> None:
     for decl in decls:
-        if isinstance(decl, QuantumFunctionDeclaration):
-            QuantumFunctionDeclaration.BUILTIN_FUNCTION_DECLARATIONS[decl.name] = decl
         if isinstance(decl, ClassicalFunctionDeclaration):
             ClassicalFunctionDeclaration.FOREIGN_FUNCTION_DECLARATIONS[decl.name] = decl
-        if isinstance(decl, StructDeclaration):
-            StructDeclaration.BUILTIN_STRUCT_DECLARATIONS[decl.name] = decl

classiq/interface/generator/chemistry_function_params.py

@@ -4,6 +4,7 @@ from classiq.interface.chemistry.ground_state_problem import (
     CHEMISTRY_PROBLEMS_TYPE,
     GroundStateProblem,
 )
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.function_params import (
     DEFAULT_INPUT_NAME,
@@ -13,16 +14,15 @@ from classiq.interface.generator.function_params import (
 
 
 class ChemistryFunctionParams(FunctionParams):
-    gs_problem: CHEMISTRY_PROBLEMS_TYPE = pydantic.Field(
-        description="Ground state problem object describing the system."
-    )
+    gs_problem: CHEMISTRY_PROBLEMS_TYPE
 
-    @pydantic.validator("gs_problem")
+    @pydantic.field_validator("gs_problem")
+    @classmethod
     def validate_gs_problem_contains_num_qubits(
         cls, gs_problem: CHEMISTRY_PROBLEMS_TYPE
     ) -> CHEMISTRY_PROBLEMS_TYPE:
         if not gs_problem.num_qubits:
-            raise ValueError(
+            raise ClassiqValueError(
                 "Ground state problem doesn't contain num_qubits. "
                 "Use update_problem method."
             )

classiq/interface/generator/circuit_code/circuit_code.py

@@ -1,7 +1,8 @@
-from typing import Dict, Optional
+from typing import Optional
 
 import pydantic
 
+from classiq.interface.exceptions import ClassiqMissingOutputFormatError
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.generator.circuit_code.types_and_constants import (
     INSTRUCTION_SET_TO_FORMAT,
@@ -12,17 +13,16 @@ from classiq.interface.generator.circuit_code.types_and_constants import (
 )
 from classiq.interface.generator.model.preferences.preferences import QuantumFormat
 
-from classiq.exceptions import ClassiqMissingOutputFormatError
-
 
 class CircuitCodeInterface(pydantic.BaseModel):
-    outputs: Dict[QuantumFormat, Code]
+    outputs: dict[QuantumFormat, Code]
     qasm_version: QasmVersion
 
-    @pydantic.validator("outputs")
+    @pydantic.field_validator("outputs")
+    @classmethod
     def reformat_long_string_output_formats(
-        cls, outputs: Dict[QuantumFormat, str]
-    ) -> Dict[QuantumFormat, LongStr]:
+        cls, outputs: dict[QuantumFormat, str]
+    ) -> dict[QuantumFormat, LongStr]:
         return {key: LongStr(value) for key, value in outputs.items()}
 
     @property

classiq/interface/generator/circuit_code/types_and_constants.py

@@ -1,22 +1,19 @@
-from typing import Dict, Tuple
-
 from typing_extensions import TypeAlias
 
+from classiq.interface.enum_utils import StrEnum
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.generator.model.preferences.preferences import QuantumFormat
 from classiq.interface.hardware import Provider
 
-from classiq._internals.enum_utils import StrEnum
-
 Code: TypeAlias = str
-CodeAndSyntax: TypeAlias = Tuple[Code, QuantumInstructionSet]
+CodeAndSyntax: TypeAlias = tuple[Code, QuantumInstructionSet]
 
-INSTRUCTION_SET_TO_FORMAT: Dict[QuantumInstructionSet, QuantumFormat] = {
+INSTRUCTION_SET_TO_FORMAT: dict[QuantumInstructionSet, QuantumFormat] = {
     QuantumInstructionSet.QASM: QuantumFormat.QASM,
     QuantumInstructionSet.QSHARP: QuantumFormat.QSHARP,
     QuantumInstructionSet.IONQ: QuantumFormat.IONQ,
 }
-VENDOR_TO_INSTRUCTION_SET: Dict[Provider, QuantumInstructionSet] = {
+VENDOR_TO_INSTRUCTION_SET: dict[Provider, QuantumInstructionSet] = {
     Provider.CLASSIQ: QuantumInstructionSet.QASM,
     Provider.IONQ: QuantumInstructionSet.IONQ,
     Provider.AZURE_QUANTUM: QuantumInstructionSet.QSHARP,

classiq/interface/generator/commuting_pauli_exponentiation.py

@@ -2,13 +2,14 @@ import pydantic
 
 from classiq.interface.chemistry import operator
 from classiq.interface.chemistry.operator import PauliOperator
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.function_params import (
     DEFAULT_INPUT_NAME,
     DEFAULT_OUTPUT_NAME,
     FunctionParams,
+    FunctionParamsNumericParameter,
 )
-from classiq.interface.generator.parameters import ParameterFloatType
 
 
 class CommutingPauliExponentiation(FunctionParams):
@@ -19,20 +20,21 @@ class CommutingPauliExponentiation(FunctionParams):
     pauli_operator: PauliOperator = pydantic.Field(
         description="A weighted sum of Pauli strings."
     )
-    evolution_coefficient: ParameterFloatType = pydantic.Field(
+    evolution_coefficient: FunctionParamsNumericParameter = pydantic.Field(
         default=1.0,
         description="A global coefficient multiplying the operator.",
-        is_exec_param=True,
     )
 
-    @pydantic.validator("pauli_operator")
+    @pydantic.field_validator("pauli_operator")
+    @classmethod
     def _validate_is_hermitian(cls, pauli_operator: PauliOperator) -> PauliOperator:
         return operator.validate_operator_is_hermitian(pauli_operator)
 
-    @pydantic.validator("pauli_operator")
+    @pydantic.field_validator("pauli_operator")
+    @classmethod
     def _validate_paulis_commute(cls, pauli_operator: PauliOperator) -> PauliOperator:
         if not pauli_operator.is_commutative:
-            raise ValueError("Pauli strings are not commutative")
+            raise ClassiqValueError("Pauli strings are not commutative")
         return pauli_operator
 
     def _create_ios(self) -> None:

classiq/interface/generator/compiler_keywords.py

@@ -0,0 +1,8 @@
+EXPANDED_KEYWORD = "expanded__"
+CAPTURE_SUFFIX = "_captured__"
+LAMBDA_KEYWORD = "lambda__"
+INPLACE_ARITH_AUX_VAR_PREFIX = "result__temp__"
+
+
+def generate_original_function_name(name: str) -> str:
+    return name.split(f"_{EXPANDED_KEYWORD}")[0]

classiq/interface/generator/complex_type.py

@@ -1,30 +1,18 @@
-from typing import Any
+from typing import Annotated, Union
 
-import pydantic.json
-from typing_extensions import Self
+from pydantic import PlainSerializer, PlainValidator
+from pydantic.json_schema import WithJsonSchema
 
 
-# Use this class as a type for complex data from the json, e.g., in the state_propagator function.
-class Complex(complex):
-    @classmethod
-    def __get_validators__(cls):
-        yield cls.validate
+def validate_complex(v: Union[complex, str]) -> complex:
+    if isinstance(v, str):
+        v = "".join(v.split())
+    return complex(v)
 
-    @classmethod
-    def __modify_schema__(cls, field_schema):
-        field_schema.update(
-            pattern=r"[+-]?\d+\.?\d* *[+-] *\d+\.?\d*j",
-        )
 
-    @classmethod
-    def validate(cls, v: Any) -> Self:
-        if isinstance(v, str):
-            v = "".join(v.split())
-
-        return cls(v)
-
-
-assert (
-    complex not in pydantic.json.ENCODERS_BY_TYPE
-), "Is complex type supported on newer version of pydantic?"
-pydantic.json.ENCODERS_BY_TYPE[complex] = str
+Complex = Annotated[
+    complex,
+    PlainValidator(validate_complex),
+    PlainSerializer(lambda x: str(x)),
+    WithJsonSchema({"type": "string", "pattern": r"[+-]?\d+\.?\d* *[+-] *\d+\.?\d*j"}),
+]

classiq/interface/generator/constant.py

@@ -1,10 +1,9 @@
-import pydantic
-
+from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.classical_type import ConcreteClassicalType
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 
 
-class Constant(pydantic.BaseModel):
+class Constant(ASTNode):
     name: str
     const_type: ConcreteClassicalType
     value: Expression

classiq/interface/generator/control_state.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
-from typing import Any, Dict
+from typing import Any
 
 import pydantic
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 
 _DEFAULT_CONTROL_NAME: str = "ctrl"
@@ -17,45 +18,52 @@ class ControlState(BaseModel):
         default=_DEFAULT_NUM_CONTROL_QUBITS, description="Number of control qubits"
     )
     ctrl_state: str = pydantic.Field(
-        default=_INVALID_CONTROL_STATE, description="Control state string"
+        default=_INVALID_CONTROL_STATE,
+        description="Control state string",
+        validate_default=True,
+    )
+    name: str = pydantic.Field(
+        default=_DEFAULT_CONTROL_NAME, description="Control name"
     )
-    name: str = pydantic.Field(default=None, description="Control name")
 
-    @pydantic.root_validator()
-    def _validate_control(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        num_ctrl_qubits: int = values.get(
-            "num_ctrl_qubits", _DEFAULT_NUM_CONTROL_QUBITS
-        )
-        ctrl_state: str = values.get("ctrl_state", _INVALID_CONTROL_STATE)
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_control(cls, values: Any) -> dict[str, Any]:
+        if isinstance(values, dict):
+            num_ctrl_qubits: int = (
+                values.get("num_ctrl_qubits", _DEFAULT_NUM_CONTROL_QUBITS) or 0
+            )
 
-        if ctrl_state == _INVALID_CONTROL_STATE:
-            ctrl_state = "1" * num_ctrl_qubits
-            values["ctrl_state"] = ctrl_state
+            ctrl_state: str = values.get("ctrl_state") or _INVALID_CONTROL_STATE
 
-        cls.validate_control_string(ctrl_state)
+            if ctrl_state == _INVALID_CONTROL_STATE:
+                ctrl_state = "1" * num_ctrl_qubits
+                values["ctrl_state"] = ctrl_state
 
-        if num_ctrl_qubits == _DEFAULT_NUM_CONTROL_QUBITS:
-            num_ctrl_qubits = len(ctrl_state)
-            values["num_ctrl_qubits"] = num_ctrl_qubits
+            cls.validate_control_string(ctrl_state)
 
-        if len(ctrl_state) != num_ctrl_qubits:
-            raise ValueError(
-                "Control state length should be equal to the number of control qubits"
-            )
+            if num_ctrl_qubits == _DEFAULT_NUM_CONTROL_QUBITS:
+                num_ctrl_qubits = len(ctrl_state)
+                values["num_ctrl_qubits"] = num_ctrl_qubits
 
-        if values.get("name") is None:
-            values["name"] = f"{_DEFAULT_CONTROL_NAME}_{ctrl_state}"
+            if len(ctrl_state) != num_ctrl_qubits:
+                raise ClassiqValueError(
+                    "Control state length should be equal to the number of control qubits"
+                )
+
+            if "name" not in values or values["name"] is None:
+                values["name"] = f"{_DEFAULT_CONTROL_NAME}_{ctrl_state}"
 
         return values
 
     @staticmethod
     def validate_control_string(ctrl_state: str) -> None:
+        if not ctrl_state:
+            raise ClassiqValueError("Control state cannot be empty")
         if not set(ctrl_state) <= {"1", "0"}:
-            raise ValueError(
+            raise ClassiqValueError(
                 f"Control state can only be constructed from 0 and 1, received: {ctrl_state}"
             )
-        if not ctrl_state:
-            raise ValueError("Control state cannot be empty")
 
     def __str__(self) -> str:
         return self.ctrl_state
@@ -70,5 +78,4 @@ class ControlState(BaseModel):
     def rename(self, name: str) -> ControlState:
         return ControlState(ctrl_state=self.ctrl_state, name=name)
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)

classiq/interface/generator/copy.py

@@ -0,0 +1,47 @@
+from typing import Optional
+
+import pydantic
+
+from classiq.interface.generator.arith import argument_utils
+from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
+from classiq.interface.generator.function_params import FunctionParams
+
+
+class Copy(FunctionParams):
+    source: argument_utils.RegisterOrConst
+    target: RegisterArithmeticInfo
+    output_size: Optional[pydantic.PositiveInt] = pydantic.Field(default=None)
+
+    @property
+    def source_size(self) -> int:
+        return argument_utils.size(self.source)
+
+    @property
+    def source_reg_size(self) -> int:
+        return (
+            self.source.size if isinstance(self.source, RegisterArithmeticInfo) else 0
+        )
+
+    @property
+    def source_fraction_places(self) -> int:
+        return argument_utils.fraction_places(self.source)
+
+    @property
+    def offset(self) -> int:
+        return self.target.fraction_places - self.source_fraction_places
+
+    @property
+    def source_name(self) -> str:
+        return "source"
+
+    @property
+    def target_name(self) -> str:
+        return "target"
+
+    def _create_ios(self) -> None:
+        self._inputs = {
+            self.target_name: self.target,
+        }
+        if isinstance(self.source, RegisterArithmeticInfo):
+            self._inputs[self.source_name] = self.source
+        self._outputs = {**self._inputs}

classiq/interface/generator/custom_ansatz.py

@@ -1,7 +1,6 @@
-from typing import Dict, Type
-
 import pydantic
 
+from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.ansatz_library import (
     EntanglingLayersArgs,
     HypercubeArgs,
@@ -11,8 +10,6 @@ from classiq.interface.generator.ansatz_library import (
     TwoLocalArgs,
 )
 
-from classiq._internals.enum_utils import StrEnum
-
 
 class CustomAnsatzType(StrEnum):
     TwoLocal = "TwoLocal"
@@ -23,7 +20,7 @@ class CustomAnsatzType(StrEnum):
     RandomTwoQubitGates = "RandomTwoQubitGates"
 
 
-CUSTOM_ANSATZ_ARGS_MAPPING: Dict[CustomAnsatzType, Type[pydantic.BaseModel]] = {
+CUSTOM_ANSATZ_ARGS_MAPPING: dict[CustomAnsatzType, type[pydantic.BaseModel]] = {
     CustomAnsatzType.TwoLocal: TwoLocalArgs,
     CustomAnsatzType.SeparateU3: SeparateU3Args,
     CustomAnsatzType.Hypercube: HypercubeArgs,

classiq/interface/generator/distance.py

@@ -1,5 +1,3 @@
-from typing import List
-
 import numpy as np
 
 # Taken and modified from quantum_tsp_tutorials repository of mstechly in github.
@@ -10,7 +8,7 @@ def _distance_between_points(point_1: np.ndarray, point_2: np.ndarray) -> float:
     return float(np.linalg.norm(point_1 - point_2))
 
 
-def get_distance_matrix(cities: np.ndarray) -> List[List[float]]:
+def get_distance_matrix(cities: np.ndarray) -> list[list[float]]:
     number_of_cities = len(cities)
     matrix = np.zeros((number_of_cities, number_of_cities))
     for i in range(number_of_cities):
@@ -20,14 +18,14 @@ def get_distance_matrix(cities: np.ndarray) -> List[List[float]]:
     return matrix.tolist()
 
 
-def get_rand_euclidean_distance_matrix(num_points: int) -> List[List[float]]:
+def get_rand_euclidean_distance_matrix(num_points: int) -> list[list[float]]:
     _points_array_dim = 2
     points = np.random.rand(num_points, _points_array_dim)
     distance_matrix = get_distance_matrix(points)
     return distance_matrix
 
 
-def get_rand_distance_matrix(num_points: int) -> List[List[float]]:
+def get_rand_distance_matrix(num_points: int) -> list[list[float]]:
     distance_matrix = np.random.rand(num_points, num_points)
     distance_matrix *= 0.5
     distance_matrix += distance_matrix.T

classiq/interface/generator/excitations.py

@@ -1,4 +1,5 @@
-from typing import Iterable, List, Union
+from collections.abc import Iterable
+from typing import Union
 
 EXCITATIONS_TYPE = Union[str, int, Iterable[int], Iterable[str]]
-EXCITATIONS_TYPE_EXACT = List[int]
+EXCITATIONS_TYPE_EXACT = list[int]

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -1,20 +1,38 @@
-SUPPORTED_BUILTIN_FUNCTIONS = {"len", "sum", "print"}
+from classiq.interface.generator.functions.classical_type import CLASSICAL_ATTRIBUTES
 
-SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {
+SUPPORTED_PYTHON_BUILTIN_FUNCTIONS = {"len", "sum", "print"}
+
+SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS = {
+    "do_div",
+    "do_slice",
+    "do_subscript",
     "hypercube_entangler_graph",
     "grid_entangler_graph",
-    "optimization_problem_to_hamiltonian",
-    "compute_qaoa_initial_point",
-    "get_optimization_solution",
+    "qft_const_adder_phase",
     "log_normal_finance_post_process",
     "gaussian_finance_post_process",
     "get_type",
     "struct_literal",
     "get_field",
-    "fraction_digits",
-    "is_signed",
     "molecule_problem_to_hamiltonian",
     "fock_hamiltonian_problem_to_hamiltonian",
     "molecule_ground_state_solution_post_process",
-    *SUPPORTED_BUILTIN_FUNCTIONS,
 }
+
+SUPPORTED_CLASSIQ_SYMPY_WRAPPERS = {
+    "BitwiseAnd",
+    "BitwiseXor",
+    "BitwiseNot",
+    "BitwiseOr",
+    "LogicalXor",
+}
+
+SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {
+    *SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS,
+    *SUPPORTED_CLASSIQ_SYMPY_WRAPPERS,
+    *SUPPORTED_PYTHON_BUILTIN_FUNCTIONS,
+}
+
+SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS_QMOD = (
+    SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS - CLASSICAL_ATTRIBUTES
+)