classiq 0.42.1__py3-none-any.whl → 0.43.0__py3-none-any.whl

classiq/__init__.py

@@ -9,17 +9,15 @@ from classiq.interface.generator.arith.register_user_input import (
     RegisterUserInput,
 )
 from classiq.interface.generator.control_state import ControlState
-from classiq.interface.generator.expressions.enums import *  # noqa: F403
-from classiq.interface.generator.expressions.enums import __all__ as _enums_all
 from classiq.interface.generator.functions import *  # noqa: F403
-from classiq.interface.generator.functions import __all__ as _ifunc_all
 from classiq.interface.generator.model import *  # noqa: F403
 from classiq.interface.generator.model import __all__ as _md_all
 from classiq.interface.generator.quantum_program import QuantumProgram
+from classiq.interface.generator.types.builtin_enum_declarations import *  # noqa: F403
 from classiq.interface.ide.show import show
 
 from classiq import applications, exceptions, execution, synthesis
-from classiq._internals import _qfunc_ext, logger
+from classiq._internals import logger
 from classiq._internals.async_utils import (
     enable_jupyter_notebook,
     is_notebook as _is_notebook,
@@ -99,11 +97,9 @@ __all__ = (
         "show",
     ]
     + _md_all
-    + _ifunc_all
     + _sub_modules
     + _application_constructors_all
     + _qmod_all
-    + _enums_all
 )
 
 

classiq/_internals/api_wrapper.py

@@ -15,13 +15,7 @@ from classiq.interface.execution.jobs import (
 from classiq.interface.executor import execution_request
 from classiq.interface.generator import quantum_program as generator_result
 from classiq.interface.hardware import HardwareInformation
-from classiq.interface.jobs import (
-    JobDescriptionBase,
-    JobDescriptionFailure,
-    JobDescriptionSuccess,
-    JobID,
-    JSONObject,
-)
+from classiq.interface.jobs import JobDescription, JobID, JSONObject
 from classiq.interface.model.model import Model
 from classiq.interface.server import routes
 
@@ -49,13 +43,13 @@ class StatusType(Protocol):
 
 
 def _parse_job_response(
-    job_result: JobDescriptionBase[JSONObject],
+    job_result: JobDescription[JSONObject],
     output_type: Type[ResultType],
 ) -> ResultType:
-    if isinstance(job_result, JobDescriptionSuccess):
-        return output_type.parse_obj(job_result.description)
-    if isinstance(job_result, JobDescriptionFailure):
-        raise ClassiqAPIError(job_result.description.details)
+    if job_result.result is not None:
+        return output_type.parse_obj(job_result.result)
+    if job_result.failure_details:
+        raise ClassiqAPIError(job_result.failure_details)
 
     raise ClassiqAPIError("Unexpected response from server")
 

classiq/_internals/authentication/token_manager.py

@@ -2,7 +2,7 @@ import argparse
 import logging
 import threading
 import warnings
-from typing import Optional
+from typing import Optional, Sequence, Type
 
 from classiq._internals.authentication import password_manager as pm
 from classiq._internals.authentication.auth0 import Auth0
@@ -13,7 +13,10 @@ from classiq.exceptions import (
     ClassiqPasswordManagerSelectionError,
 )
 
-PASSWORD_MANAGERS = [pm.KeyringPasswordManager, pm.FilePasswordManager]
+PASSWORD_MANAGERS: Sequence[Type[pm.PasswordManager]] = [
+    pm.KeyringPasswordManager,
+    pm.FilePasswordManager,
+]
 _logger = logging.getLogger(__name__)
 
 

classiq/_internals/jobs.py

@@ -5,12 +5,7 @@ from typing import Callable, Dict, Iterable, Optional, Set, TypeVar
 import httpx
 import pydantic
 
-from classiq.interface.jobs import (
-    JobDescriptionBase,
-    JobDescriptionUnion,
-    JobID,
-    JSONObject,
-)
+from classiq.interface.jobs import JobDescription, JobID, JSONObject
 
 from classiq._internals.async_utils import poll_for
 from classiq._internals.client import client, try_again_on_failure
@@ -18,7 +13,7 @@ from classiq._internals.config import SDKMode
 from classiq.exceptions import ClassiqAPIError
 
 _URL_PATH_SEP = "/"
-GeneralJobDescription = JobDescriptionBase[JSONObject]
+GeneralJobDescription = JobDescription[JSONObject]
 _logger = logging.getLogger(__name__)
 T = TypeVar("T")
 
@@ -42,9 +37,9 @@ def _join_url_path(*parts: str) -> str:
 def _general_job_description_parser(
     json_response: JSONObject,
 ) -> Optional[GeneralJobDescription]:
-    job_description = JobDescriptionUnion[JSONObject].parse_obj(json_response)
-    if job_description.__root__.status.is_final():
-        return job_description.__root__
+    job_description = GeneralJobDescription.parse_obj(json_response)
+    if job_description.status.is_final():
+        return job_description
     return None
 
 

classiq/analyzer/rb.py

@@ -1,4 +1,4 @@
-from enum import Enum
+from enum import Enum as PythonEnum
 from typing import Dict, List, Optional, Set, Union
 
 import matplotlib.pyplot as plt
@@ -78,8 +78,8 @@ class RBAnalysis:
         return fig
 
 
-def _strict_string(arg: Union[Enum, str]) -> str:
-    if isinstance(arg, Enum):
+def _strict_string(arg: Union[PythonEnum, str]) -> str:
+    if isinstance(arg, PythonEnum):
         return arg.value
     return arg
 

classiq/applications/chemistry/chemistry_model_constructor.py

@@ -18,7 +18,7 @@ from classiq.interface.chemistry.ground_state_problem import (
     MoleculeProblem,
 )
 from classiq.interface.chemistry.molecule import Atom
-from classiq.interface.generator.expressions.enums.chemistry import (
+from classiq.qmod.builtins.enums import (
     Element,
     FermionMapping,
 )
@@ -51,6 +51,7 @@ from classiq.applications.chemistry.chemistry_execution_parameters import (
     ChemistryExecutionParameters,
 )
 from classiq.exceptions import ClassiqError
+from classiq.qmod.utilities import qmod_val_to_expr_str
 
 _LADDER_OPERATOR_TYPE_INDICATOR_TO_QMOD_MAPPING: Dict[str, str] = {
     "+": "PLUS",
@@ -153,7 +154,7 @@ _HAE_GATE_MAPPING: Dict[str, QuantumFunctionCall] = {
     ),
     "crx": QuantumFunctionCall(
         function="CRX",
-        params={"theta": Expression(expr="angle")},
+        designated_params={"theta": Expression(expr="angle")},
         positional_args=[
             Expression(expr="angle"),
             HandleBinding(name="q1"),
@@ -194,7 +195,7 @@ _HAE_GATE_MAPPING: Dict[str, QuantumFunctionCall] = {
 def _atoms_to_qmod_atoms(atoms: List[Atom]) -> List[QmodChemistryAtom]:
     return [
         QmodChemistryAtom(
-            element=Element[atom.symbol],
+            element=Element[atom.symbol],  # type:ignore[arg-type]
             position=QmodPosition(
                 x=atom.x,  # type:ignore[arg-type]
                 y=atom.y,  # type:ignore[arg-type]
@@ -209,7 +210,9 @@ def molecule_problem_to_qmod(
     molecule_problem: MoleculeProblem,
 ) -> QmodMoleculeProblem:
     return QmodMoleculeProblem(
-        mapping=FermionMapping[molecule_problem.mapping.value.upper()],
+        mapping=FermionMapping[  # type:ignore[arg-type]
+            molecule_problem.mapping.value.upper()
+        ],
         z2_symmetries=molecule_problem.z2_symmetries,  # type:ignore[arg-type]
         molecule=QmodMolecule(
             atoms=_atoms_to_qmod_atoms(
@@ -256,11 +259,12 @@ def _summed_fermionic_operator_to_qmod_lader_terms(
 def _hamiltonian_problem_to_qmod_fock_hamiltonian_problem(
     hamiltonian_problem: HamiltonianProblem,
 ) -> str:
+    mapping = FermionMapping[hamiltonian_problem.mapping.value.upper()]
     return (
         # fmt: off
         "struct_literal("
         "FockHamiltonianProblem,"
-        f"mapping={FermionMapping[hamiltonian_problem.mapping.value.upper()]},"
+        f"mapping={qmod_val_to_expr_str(mapping)},"
         f"z2_symmetries={hamiltonian_problem.z2_symmetries},"
         f"terms=[{_summed_fermionic_operator_to_qmod_lader_terms(hamiltonian_problem.hamiltonian)}],"
         f"num_particles={hamiltonian_problem.num_particles}"
@@ -271,7 +275,7 @@ def _hamiltonian_problem_to_qmod_fock_hamiltonian_problem(
 
 def _convert_library_problem_to_qmod_problem(problem: CHEMISTRY_PROBLEMS_TYPE) -> str:
     if isinstance(problem, MoleculeProblem):
-        return str(molecule_problem_to_qmod(problem))
+        return qmod_val_to_expr_str(molecule_problem_to_qmod(problem))
     elif isinstance(problem, HamiltonianProblem):
         return _hamiltonian_problem_to_qmod_fock_hamiltonian_problem(problem)
     else:
@@ -368,13 +372,13 @@ def _get_molecule_problem_execution_post_processing(
     molecule_problem: MoleculeProblem,
 ) -> str:
     return f"""
-{_MOLECULE_PROBLEM_RESULT} = molecule_ground_state_solution_post_process({molecule_problem_to_qmod(molecule_problem)},{_EXECUTION_RESULT})
+{_MOLECULE_PROBLEM_RESULT} = molecule_ground_state_solution_post_process({qmod_val_to_expr_str(molecule_problem_to_qmod(molecule_problem))},{_EXECUTION_RESULT})
 save({{{_MOLECULE_PROBLEM_RESULT!r}: {_MOLECULE_PROBLEM_RESULT}}})
 """
 
 
 def _is_parametric_gate(call: QuantumFunctionCall) -> bool:
-    return len(call.params) > 0 or any(
+    return len(call.designated_params) > 0 or any(
         isinstance(arg, Expression) for arg in call.positional_args
     )
 

classiq/applications/combinatorial_helpers/pauli_helpers/pauli_utils.py

@@ -1,11 +1,11 @@
 from typing import List
 
-from classiq.interface.generator.expressions.enums.pauli import Pauli
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
 from classiq.interface.helpers.custom_pydantic_types import PydanticPauliList
 
 from classiq.exceptions import ClassiqNonNumericCoefficientInPauliError
 from classiq.qmod.builtins import PauliTerm
+from classiq.qmod.builtins.enums import Pauli
 
 
 def pauli_operator_to_hamiltonian(pauli_list: PydanticPauliList) -> List[PauliTerm]:
@@ -30,7 +30,7 @@ def pauli_enum_to_str(pauli: Pauli) -> str:
         Pauli.X: "Pauli.X",
         Pauli.Y: "Pauli.Y",
         Pauli.Z: "Pauli.Z",
-    }.get(pauli, "")
+    }[pauli]
 
 
 def _pauli_terms_to_qmod(hamiltonian: List[PauliTerm]) -> str:

classiq/applications/finance/finance_model_constructor.py

@@ -19,13 +19,11 @@ from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 
-from classiq.applications.libraries.ampltitude_estimation_library import (
-    AE_CLASSICAL_LIBRARY,
-)
 from classiq.applications.libraries.qmci_library import QMCI_LIBRARY
 from classiq.exceptions import ClassiqError
+from classiq.qmod.utilities import qmod_val_to_expr_str
 
-_OUTPUT_VARIABLE_NAME = "result"
+_OUTPUT_VARIABLE_NAME = "payoff_estimation"
 
 
 def construct_finance_model(
@@ -59,7 +57,7 @@ def construct_finance_model(
     if finance_function_input.tail_probability is not None:
         tail_probability = finance_function_input.tail_probability
 
-    finance_function_object = f"struct_literal(FinanceFunction, f={finance_function_input.f}, threshold={finance_function_input.condition.threshold}, larger={finance_function_input.condition.larger}, polynomial_degree={polynomial_degree}, use_chebyshev_polynomial_approximation={finance_function_input.use_chebyshev_polynomial_approximation}, tail_probability={tail_probability})"
+    finance_function_object = f"struct_literal(FinanceFunction, f={qmod_val_to_expr_str(finance_function_input.f)}, threshold={finance_function_input.condition.threshold}, larger={finance_function_input.condition.larger}, polynomial_degree={polynomial_degree}, use_chebyshev_polynomial_approximation={finance_function_input.use_chebyshev_polynomial_approximation}, tail_probability={tail_probability})"
     num_unitary_qubits = total_num_qubits + 1
 
     model = Model(
@@ -117,13 +115,18 @@ def construct_finance_model(
                 ],
             ),
         ],
-        classical_execution_code=(
-            AE_CLASSICAL_LIBRARY
-            + f"""
-estimation = execute_amplitude_estimation({phase_port_size})
-{_OUTPUT_VARIABLE_NAME} = {post_process_function}({finance_model}, {finance_function_object}, estimation)
-save({{{_OUTPUT_VARIABLE_NAME!r}: {_OUTPUT_VARIABLE_NAME}}})
-"""
-        ).strip(),
+        classical_execution_code=f"""
+phase_port_size = {phase_port_size}
+counts = sample()
+save({{"counts": counts}})
+probability_estimation = qae_with_qpe_result_post_processing(
+    estimation_register_size=phase_port_size,
+    estimation_method=1,
+    result=counts
+)
+save({{"probability_estimation": probability_estimation}})
+{_OUTPUT_VARIABLE_NAME} = {post_process_function}({finance_model}, {finance_function_object}, probability_estimation)
+save({{"{_OUTPUT_VARIABLE_NAME}": {_OUTPUT_VARIABLE_NAME}}})
+""".strip(),
     )
     return model.get_model()

classiq/applications/qsvm/__init__.py

@@ -1,6 +1,4 @@
-from classiq.interface.generator.expressions.enums.qsvm_feature_map_entanglement import (
-    QSVMFeatureMapEntanglement,
-)
+from classiq.qmod.builtins.enums import QSVMFeatureMapEntanglement
 
 from ..qsvm import qsvm_data_generation
 from .qsvm import *  # noqa: F403

classiq/applications/qsvm/qsvm_model_constructor.py

@@ -1,10 +1,6 @@
 from typing import Any, List, Tuple
 
 from classiq.interface.applications.qsvm import DataList, LabelsInt
-from classiq.interface.generator.expressions.enums.pauli import Pauli
-from classiq.interface.generator.expressions.enums.qsvm_feature_map_entanglement import (
-    QSVMFeatureMapEntanglement,
-)
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -16,6 +12,8 @@ from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 
 from classiq.exceptions import ClassiqValueError
+from classiq.qmod.builtins.enums import Pauli, QSVMFeatureMapEntanglement
+from classiq.qmod.utilities import qmod_val_to_expr_str
 
 INVALID_FEATURE_MAP_FUNC_NAME_MSG = "Invalid feature_map_function_name, it can be bloch_sphere_feature_map or pauli_feature_map"
 
@@ -40,13 +38,16 @@ def _pauli_feature_map_function_params(
     paulis_str = (
         "["
         + ",".join(
-            ["[" + ",".join([str(p) for p in p_list]) + "]" for p_list in paulis]
+            [
+                "[" + ",".join([qmod_val_to_expr_str(p) for p in p_list]) + "]"
+                for p_list in paulis
+            ]
         )
         + "]"
     )
     pauli_feature_map_params = (
         f"paulis={paulis_str}, "
-        f"entanglement={entanglement}, "
+        f"entanglement={qmod_val_to_expr_str(entanglement)}, "
         f"alpha={alpha}, "
         f"reps={reps}, "
         f"feature_dimension={feature_dimension}"

classiq/exceptions.py

@@ -4,16 +4,17 @@ from typing import Iterable, List
 _logger = logging.getLogger(__name__)
 
 CLASSIQ_SLACK_COMMUNITY_LINK = (
-    "\nIf you need further assistance, please reach out on our Community Slack channel at: https://short.classiq.io/join-slack"
-    "\nIf the error persists feel free to open a ticket at: https://short.classiq.io/support"
+    "\nIf you need further assistance, please reach out on our Community Slack channel "
+    "at: https://short.classiq.io/join-slack"
 )
 
 
 class ClassiqError(Exception):
     def __init__(self, message: str) -> None:
-        message_with_link = message + CLASSIQ_SLACK_COMMUNITY_LINK
-        super().__init__(message_with_link)
         self._raw_message = message
+        if CLASSIQ_SLACK_COMMUNITY_LINK not in message:
+            message = message + CLASSIQ_SLACK_COMMUNITY_LINK
+        super().__init__(message)
 
     @property
     def raw_message(self) -> str:
@@ -171,3 +172,7 @@ class ClassiqExecutorInvalidHamiltonianError(ClassiqCombOptError):
 
     def __init__(self) -> None:
         super().__init__("Invalid hamiltonian")
+
+
+class ClassiqSemanticError(ClassiqError):
+    pass

classiq/execution/execution_session.py

@@ -19,7 +19,10 @@ from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import
 from classiq.exceptions import ClassiqValueError
 from classiq.executor import execute
 from classiq.qmod.builtins import PauliTerm
-from classiq.qmod.builtins.classical_execution_primitives import ExecutionParams
+from classiq.qmod.builtins.classical_execution_primitives import (
+    CARRAY_SEPARATOR,
+    ExecutionParams,
+)
 from classiq.synthesis import SerializedQuantumProgram
 
 Hamiltonian = Union[List[QmodPyStruct], List[PauliTerm]]
@@ -70,7 +73,7 @@ def parse_params(params: ExecutionParams) -> ParsedExecutionParams:
     for key, values in params.items():
         if isinstance(values, list):
             for index, value in enumerate(values):
-                new_key = f"{key}_{index}"
+                new_key = f"{key}{CARRAY_SEPARATOR}{index}"
                 result[new_key] = value
         elif isinstance(values, (int, float)):
             result[key] = values

classiq/execution/qnn.py

@@ -4,6 +4,7 @@ from typing import List, Optional
 import more_itertools
 
 from classiq.interface.chemistry.operator import PauliOperator
+from classiq.interface.executor.constants import DEFAULT_RESULT_NAME
 from classiq.interface.executor.execution_result import (
     ResultsCollection,
     SavedResultValueType,
@@ -16,7 +17,6 @@ from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import
     pauli_operator_to_hamiltonian,
 )
 from classiq.execution.execution_session import ExecutionSession
-from classiq.executor import DEFAULT_RESULT_NAME
 from classiq.synthesis import SerializedQuantumProgram
 
 _MAX_ARGUMENTS_SIZE = 1024

classiq/executor.py

@@ -17,8 +17,6 @@ from classiq._internals.async_utils import syncify_function
 from classiq.execution.jobs import ExecutionJob
 from classiq.synthesis import SerializedQuantumProgram
 
-DEFAULT_RESULT_NAME = "result"
-
 BatchExecutionResult: TypeAlias = Union[ExecutionDetails, BaseException]
 ProgramAndResult: TypeAlias = Tuple[QuantumCode, BatchExecutionResult]
 BackendPreferencesAndResult: TypeAlias = Tuple[

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.42.1'
+SEMVER_VERSION = '0.43.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/chemistry/operator.py

@@ -1,12 +1,21 @@
 from functools import reduce
-from typing import Any, Collection, Dict, List, Optional, Tuple, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Collection,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Union,
+    cast,
+)
 
 import numpy as np
 import pydantic
 import sympy
 from more_itertools import all_equal
 
-from classiq.interface.generator.expressions.enums.pauli import Pauli
 from classiq.interface.generator.function_params import validate_expression_str
 from classiq.interface.generator.parameters import (
     ParameterComplexType,
@@ -25,6 +34,9 @@ from classiq.interface.helpers.versioned_model import VersionedModel
 
 from classiq.exceptions import ClassiqValueError
 
+if TYPE_CHECKING:
+    from classiq.qmod.builtins.enums import Pauli
+
 
 class PauliOperator(HashablePydanticBaseModel, VersionedModel):
     """
@@ -204,7 +216,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
     @classmethod
     def from_unzipped_lists(
         cls,
-        operators: List[List[Pauli]],
+        operators: List[List["Pauli"]],
         coefficients: Optional[List[complex]] = None,
     ) -> "PauliOperator":
         if coefficients is None:
@@ -404,7 +416,7 @@ class PauliOperatorV1(HashablePydanticBaseModel):
     @classmethod
     def from_unzipped_lists(
         cls,
-        operators: List[List[Pauli]],
+        operators: List[List["Pauli"]],
         coefficients: Optional[List[complex]] = None,
     ) -> "PauliOperatorV1":
         if coefficients is None:
@@ -466,7 +478,9 @@ def validate_operator_has_no_complex_coefficients(
     return pauli_operator
 
 
-def pauli_integers_to_str(paulis: List[Pauli]) -> str:
+def pauli_integers_to_str(paulis: List["Pauli"]) -> str:
+    from classiq.qmod.builtins.enums import Pauli
+
     return "".join([Pauli(pauli).name for pauli in paulis])
 
 

classiq/interface/executor/constants.py

@@ -0,0 +1 @@
+DEFAULT_RESULT_NAME = "result"

classiq/interface/finance/function_input.py

@@ -1,10 +1,9 @@
-from typing import Any, Dict, Optional, Union
+from typing import TYPE_CHECKING, Any, Dict, Optional, Union
 
 import pydantic
 
 from classiq.interface.generator.expressions.enums.finance_functions import (
-    FINANCE_FUNCTION_STRING,
-    FinanceFunctionType,
+    get_finance_function_dict,
 )
 from classiq.interface.helpers.custom_pydantic_types import (
     PydanticNonZeroProbabilityFloat,
@@ -12,6 +11,9 @@ from classiq.interface.helpers.custom_pydantic_types import (
 
 from classiq.exceptions import ClassiqValueError
 
+if TYPE_CHECKING:
+    from classiq.qmod.builtins.enums import FinanceFunctionType
+
 
 class FunctionCondition(pydantic.BaseModel):
     threshold: float
@@ -25,7 +27,7 @@ class FunctionCondition(pydantic.BaseModel):
 
 
 class FinanceFunctionInput(pydantic.BaseModel):
-    f: FinanceFunctionType = pydantic.Field(
+    f: "FinanceFunctionType" = pydantic.Field(
         description="An enumeration of the wanted financial function: VaR, expected "
         "shortfall, European call options or x^2"
     )
@@ -50,10 +52,10 @@ class FinanceFunctionInput(pydantic.BaseModel):
     )
 
     @pydantic.validator("f", pre=True)
-    def _convert_f_if_str(cls, f: Any) -> FinanceFunctionType:
+    def _convert_f_if_str(cls, f: Any) -> "FinanceFunctionType":
         # Keep this for backwards-compatible string support
-        if f in FINANCE_FUNCTION_STRING:
-            return FINANCE_FUNCTION_STRING[f]
+        if f in get_finance_function_dict():
+            return get_finance_function_dict()[f]
         return f
 
     @pydantic.validator("use_chebyshev_polynomial_approximation")
@@ -68,13 +70,15 @@ class FinanceFunctionInput(pydantic.BaseModel):
 
     @pydantic.validator("f")
     def _validate_finance_function(
-        cls, f: Union[int, str, FinanceFunctionType]
-    ) -> FinanceFunctionType:
+        cls, f: Union[int, str, "FinanceFunctionType"]
+    ) -> "FinanceFunctionType":
+        from classiq.qmod.builtins.enums import FinanceFunctionType
+
         if isinstance(f, FinanceFunctionType):
             return f
         if isinstance(f, int):
             return FinanceFunctionType(f)
-        return FinanceFunctionType.from_string(f)
+        return get_finance_function_dict()[f]
 
     @pydantic.validator("tail_probability", always=True)
     def _validate_tail_probability_assignment_for_shortfall(
@@ -82,6 +86,8 @@ class FinanceFunctionInput(pydantic.BaseModel):
         tail_probability: Optional[PydanticNonZeroProbabilityFloat],
         values: Dict[str, Any],
     ) -> Optional[PydanticNonZeroProbabilityFloat]:
+        from classiq.qmod.builtins.enums import FinanceFunctionType
+
         if values.get("f") == FinanceFunctionType.SHORTFALL and not tail_probability:
             raise ClassiqValueError(
                 "Tail probability must be set for expected shortfall"

classiq/interface/generator/application_apis/chemistry_declarations.py

@@ -9,9 +9,9 @@ from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalList,
     Integer,
-    LadderOperator,
     Real,
     Struct,
+    TypeName,
     VQEResult,
 )
 from classiq.interface.generator.functions.port_declaration import (
@@ -169,7 +169,7 @@ LADDER_TERM = StructDeclaration(
 LADDER_OP = StructDeclaration(
     name="LadderOp",
     variables={
-        "op": LadderOperator(),
+        "op": TypeName(name="LadderOperator"),
         "index": Integer(),
     },
 )

classiq/interface/generator/application_apis/qsvm_declarations.py

@@ -3,8 +3,8 @@ import enum
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
     ClassicalList,
+    Enum,
     Integer,
-    Pauli,
     Real,
     Struct,
 )
@@ -56,7 +56,9 @@ QSVM_FEATURE_MAP_PAULI = StructDeclaration(
         "reps": Integer(),
         "entanglement": Integer(),
         "alpha": Real(),
-        "paulis": ClassicalList(element_type=ClassicalList(element_type=Pauli())),
+        "paulis": ClassicalList(
+            element_type=ClassicalList(element_type=Enum(name="Pauli"))
+        ),
     },
 )
 

classiq/interface/generator/arith/argument_utils.py

@@ -49,10 +49,27 @@ def bounds(argument: RegisterOrConst) -> Tuple[float, float]:
 
 
 def limit_fraction_places(
-    argument: RegisterOrConst, *, machine_precision: int
+    argument: RegisterOrConst, machine_precision: int
 ) -> RegisterOrConst:
     if isinstance(argument, RegisterArithmeticInfo):
         return argument.limit_fraction_places(machine_precision)
-    return number_utils.limit_fraction_places(
-        argument, machine_precision=machine_precision
+    return number_utils.limit_fraction_places(argument, machine_precision)
+
+
+def arg_bounds_overlap(args: Tuple[RegisterOrConst, RegisterOrConst]) -> bool:
+    return (max(bounds(args[0])) - min(bounds(args[1]))) * (
+        min(bounds(args[0])) - max(bounds(args[1]))
+    ) < 0
+
+
+def as_arithmetic_info(
+    arg: RegisterOrConst, with_bounds: bool = True
+) -> RegisterArithmeticInfo:
+    if isinstance(arg, RegisterArithmeticInfo):
+        return arg
+    return RegisterArithmeticInfo(
+        size=number_utils.size(arg),
+        is_signed=arg < 0,
+        fraction_places=number_utils.fraction_places(arg),
+        bounds=(arg, arg) if with_bounds else None,
     )