classiq 0.43.2__py3-none-any.whl → 0.44.0__py3-none-any.whl

classiq/__init__.py

@@ -14,7 +14,6 @@ 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 logger
@@ -38,6 +37,10 @@ from classiq.applications.combinatorial_optimization import (
 )
 from classiq.applications.finance import construct_finance_model
 from classiq.applications.grover import construct_grover_model
+from classiq.applications.hamiltonian.pauli_decomposition import (
+    hamiltonian_to_matrix,
+    matrix_to_hamiltonian,
+)
 from classiq.applications.qsvm import construct_qsvm_model
 from classiq.executor import (
     execute,
@@ -46,6 +49,7 @@ from classiq.executor import (
 )
 from classiq.qmod import *  # noqa: F403
 from classiq.qmod import __all__ as _qmod_all
+from classiq.show import show
 from classiq.synthesis import (
     set_constraints,
     set_execution_preferences,
@@ -95,6 +99,8 @@ __all__ = (
         "set_execution_preferences",
         "set_quantum_program_execution_preferences",
         "show",
+        "hamiltonian_to_matrix",
+        "matrix_to_hamiltonian",
     ]
     + _md_all
     + _sub_modules

classiq/_internals/client.py

@@ -19,10 +19,10 @@ from typing import (
 )
 
 import httpx
-from packaging.version import Version
 from typing_extensions import ParamSpec
 
 from classiq.interface._version import VERSION as _VERSION
+from classiq.interface.interface_version import INTERFACE_VERSION
 
 from classiq._internals import config
 from classiq._internals.authentication import token_manager
@@ -161,12 +161,9 @@ class Client:
         self._api_prefix = self._make_api_prefix()
         self._session_id: Optional[str] = None
 
-    @classmethod
-    def _make_api_prefix(cls) -> str:
-        if _VERSION == cls._UNKNOWN_VERSION:
-            return cls._LATEST_VERSION_API_PREFIX
-        parsed_version = Version(_VERSION)
-        return f"/api/v{parsed_version.major}-{parsed_version.minor}"
+    @staticmethod
+    def _make_api_prefix() -> str:
+        return f"/api/v{INTERFACE_VERSION}"
 
     def make_versioned_url(self, url_postfix: str) -> str:
         return self._api_prefix + url_postfix

classiq/_internals/host_checker.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import logging
+import warnings
+from datetime import datetime
 from typing import TYPE_CHECKING, Optional
 
 import httpx
@@ -8,9 +10,10 @@ import pydantic
 from packaging.version import Version
 from pydantic import BaseModel
 
+from classiq.interface.interface_version import INTERFACE_VERSION
 from classiq.interface.server.global_versions import DeprecationInfo, GlobalVersions
 
-from classiq.exceptions import ClassiqAPIError
+from classiq.exceptions import ClassiqAPIError, ClassiqDeprecationWarning
 
 if TYPE_CHECKING:
     from classiq._internals.client import Client
@@ -26,9 +29,23 @@ class HostVersions(BaseModel):
 class HostChecker:
     _UNKNOWN_VERSION = "0.0.0"
 
-    def __init__(self, client: Client, client_version: str) -> None:
+    def __init__(
+        self,
+        client: Client,
+        client_version: str,
+        interface_version: str = INTERFACE_VERSION,
+    ) -> None:
         self._client = client
         self._client_version = client_version
+        self._interface_version = interface_version
+
+    def _get_interface_version(self) -> Optional[str]:
+        global_interfaces = GlobalVersions.parse_obj(
+            self._client.sync_call_api(
+                "get", "/interface_versions", use_versioned_url=False
+            )
+        )
+        return global_interfaces.deployed.get(self._interface_version, None)
 
     def _get_host_version(self) -> str:
         host = HostVersions.parse_obj(self._client.sync_call_api("get", "/versions"))
@@ -56,18 +73,16 @@ class HostChecker:
 
     def check_host_version(self) -> None:
         try:
-            raw_host_version = self._get_host_version()
+            interface_version = self._get_interface_version()
         except httpx.ConnectError:
             _logger.warning(
                 "Version check failed - host unavailable.",
             )
         else:
-            if not self._check_matching_versions(
-                raw_host_version, self._client_version
-            ):
+            if interface_version is None:
                 raise ClassiqAPIError(
-                    f"Classiq API version mismatch: 'classiq' version is "
-                    f"{self._client_version}, backend version is {raw_host_version}. {_VERSION_UPDATE_SUGGESTION}"
+                    f"You are using an unsupported version of Classiq SDK - {self._client_version}. "
+                    f"{_VERSION_UPDATE_SUGGESTION}"
                 )
 
     def check_deprecated_version(self) -> None:
@@ -80,8 +95,15 @@ class HostChecker:
         else:
             if deprecation_info is None:
                 return
-            _logger.warning(
-                "The current version of 'classiq' has been deprecated, and will not be supported as of %s. %s",
-                deprecation_info.removal_date.date(),
-                _VERSION_UPDATE_SUGGESTION,
+            removal_date = (
+                deprecation_info.removal_date.date()
+                if isinstance(deprecation_info.removal_date, datetime)
+                else deprecation_info.removal_date
+            )
+            warnings.warn(
+                f"The current version of 'classiq' has been deprecated, and"
+                f" will not be supported as of {removal_date}. "
+                f"{_VERSION_UPDATE_SUGGESTION}",
+                ClassiqDeprecationWarning,
+                stacklevel=2,
             )

classiq/_internals/jobs.py

@@ -169,7 +169,7 @@ class JobPoller:
         self, model: pydantic.BaseModel, timeout_sec: Optional[float]
     ) -> GeneralJobDescription:
         # TODO: we can't use model.dict() - it doesn't serialize complex class.
-        # This was added because JSON serializer doesn't serialize complex type, and pydantic does.
-        # We should add support for smarter json serialization.
+        # This was added because JSON serializer doesn't serialize complex and UUID,
+        # while pydantic does. We should add support for smarter json serialization.
         body = json.loads(model.json())
         return await self.run(body, timeout_sec)

classiq/applications/chemistry/chemistry_model_constructor.py

@@ -154,7 +154,6 @@ _HAE_GATE_MAPPING: Dict[str, QuantumFunctionCall] = {
     ),
     "crx": QuantumFunctionCall(
         function="CRX",
-        designated_params={"theta": Expression(expr="angle")},
         positional_args=[
             Expression(expr="angle"),
             HandleBinding(name="q1"),
@@ -325,11 +324,17 @@ def _get_hea_function(hea_parameters: HEAParameters) -> QuantumFunctionCall:
             ),
             Expression(expr=f"{hea_parameters.reps}"),
             [
-                QuantumLambdaFunction(body=[_HAE_GATE_MAPPING[gate]])
+                QuantumLambdaFunction(
+                    pos_rename_params=["angle", "q"],
+                    body=[_HAE_GATE_MAPPING[gate]],
+                )
                 for gate in hea_parameters.one_qubit_gates
             ],
             [
-                QuantumLambdaFunction(body=[_HAE_GATE_MAPPING[gate]])
+                QuantumLambdaFunction(
+                    pos_rename_params=["angle", "q1", "q2"],
+                    body=[_HAE_GATE_MAPPING[gate]],
+                )
                 for gate in hea_parameters.two_qubit_gates
             ],
             HandleBinding(name="qbv"),
@@ -378,9 +383,10 @@ save({{{_MOLECULE_PROBLEM_RESULT!r}: {_MOLECULE_PROBLEM_RESULT}}})
 
 
 def _is_parametric_gate(call: QuantumFunctionCall) -> bool:
-    return len(call.designated_params) > 0 or any(
-        isinstance(arg, Expression) for arg in call.positional_args
-    )
+    # FIXME: call call.params instead (CAD-21568)
+    return any(
+        arg for arg in call.positional_args if isinstance(arg, Expression)
+    ) or any(isinstance(arg, Expression) for arg in call.positional_args)
 
 
 def _get_execution_result_post_processing_statements(

classiq/applications/combinatorial_helpers/allowed_constraints.py

@@ -15,6 +15,9 @@ def is_constraint_sum_less_than_one(
         isinstance(expression, LessThan)
         and isinstance(expression.args[0], Add)
         and all(isinstance(arg, Symbol) for arg in expression.args[0].args)
-        and expression.args[1] == _INEQUALITY_UPPER_LIMIT
+        and (
+            expression.args[1] == _INEQUALITY_UPPER_LIMIT
+            or expression.args[1] == float(_INEQUALITY_UPPER_LIMIT)
+        )
         and encoding_type is None
     )

classiq/applications/combinatorial_optimization/combinatorial_optimization_model_constructor.py

@@ -9,7 +9,6 @@ from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
     ClassicalList,
     Real,
-    Struct,
 )
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -24,6 +23,7 @@ from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_type import QuantumBitvector
 
+from classiq import Struct
 from classiq.applications.combinatorial_helpers.combinatorial_problem_utils import (
     compute_qaoa_initial_point,
     convert_pyomo_to_global_presentation,

classiq/applications/finance/finance_model_constructor.py

@@ -96,14 +96,15 @@ def construct_finance_model(
                         function="qmci",
                         positional_args=[
                             QuantumLambdaFunction(
+                                pos_rename_params=["state", "ind"],
                                 body=[
                                     QuantumFunctionCall(
                                         function=finance_function,
                                         positional_args=[
                                             Expression(expr=finance_model),
                                             Expression(expr=finance_function_object),
-                                            HandleBinding(name="arg0"),
-                                            HandleBinding(name="arg1"),
+                                            HandleBinding(name="state"),
+                                            HandleBinding(name="ind"),
                                         ],
                                     ),
                                 ],

classiq/applications/grover/grover_model_constructor.py

@@ -34,7 +34,7 @@ def _arithmetic_oracle_ios(
     for _, reg in definitions:
         ios.append(
             SlicedHandleBinding(
-                name=handle_name,
+                base_handle=HandleBinding(name=handle_name),
                 start=Expression(expr=f"{cursor}"),
                 end=Expression(expr=f"{cursor + reg.size}"),
             )
@@ -47,12 +47,13 @@ def _construct_arithmetic_oracle(
     predicate_function: str,
     definitions: List[Tuple[str, RegisterUserInput]],
 ) -> QuantumFunctionCall:
-    predicate_var_binding = _arithmetic_oracle_ios(definitions, "arg0")
-    predicate_var_binding.append(HandleBinding(name="arg1"))
+    predicate_var_binding = _arithmetic_oracle_ios(definitions, "state")
+    predicate_var_binding.append(HandleBinding(name="oracle"))
     return QuantumFunctionCall(
         function="phase_oracle",
         positional_args=[
             QuantumLambdaFunction(
+                pos_rename_params=["state", "oracle"],
                 body=[
                     QuantumFunctionCall(
                         function=predicate_function,
@@ -60,7 +61,7 @@ def _construct_arithmetic_oracle(
                     ),
                 ],
             ),
-            HandleBinding(name="arg0"),
+            HandleBinding(name="packed_vars"),
         ],
     )
 
@@ -132,12 +133,13 @@ def construct_grover_model(
                         positional_args=[
                             Expression(expr=f"{num_reps}"),
                             QuantumLambdaFunction(
+                                pos_rename_params=["packed_vars"],
                                 body=[
                                     _construct_arithmetic_oracle(
                                         _PREDICATE_FUNCTION_NAME,
                                         definitions,
                                     )
-                                ]
+                                ],
                             ),
                             HandleBinding(name="packed_vars"),
                         ],

classiq/applications/hamiltonian/pauli_decomposition.py

@@ -0,0 +1,113 @@
+from typing import List, Tuple, Union
+
+import numpy as np
+from sympy import fwht
+
+from classiq.qmod import (  # type:ignore[attr-defined]
+    Pauli,
+    PauliTerm,
+)
+
+ATOL = 1e-12
+PAULI_MATRICES_DICT = {
+    Pauli.I: np.array([[1, 0], [0, 1]], dtype=np.complex128),
+    Pauli.Z: np.array([[1, 0], [0, -1]], dtype=np.complex128),
+    Pauli.X: np.array([[0, 1], [1, 0]], dtype=np.complex128),
+    Pauli.Y: np.array([[0, -1j], [1j, 0]], dtype=np.complex128),
+}
+
+
+def _get_pauli_string(set_index: int, term_index: int, num_qubits: int) -> List[Pauli]:
+    """
+    The basis of 4^N Pauli strings on N qubits can be partitioned to 2^N sets, each contains 2^N Pauli strings.
+    In the k-th set we have Pauli strings of the form s_1s_2...s_N, where s_j is in {I,Z} if k_j is 0,
+    and in {X,iY} if k_j=1. The function get_pauli_string returns the m-th Pauli string in the k-th set of Pauli strings
+    """
+
+    # returns the Pauli (I,Z) or (iY, X) appearing in the pauli_index position for a given set
+    def _get_paulis_for_set(set_index: int, pauli_index: int) -> Tuple[Pauli, Pauli]:
+        if (set_index >> pauli_index) & 1:
+            return Pauli.Y, Pauli.X
+        else:
+            return Pauli.Z, Pauli.I
+
+    return [
+        (
+            _get_paulis_for_set(set_index, s)[0]
+            if (term_index >> s) & 1
+            else _get_paulis_for_set(set_index, s)[1]
+        )
+        for s in range(num_qubits)
+    ][::-1]
+
+
+def _coefficents_for_set(mat: np.ndarray, set_index: int) -> list:
+    """
+    The 2^N coefficients in a 2^N x 2^N matrix that are decomposed to the elements
+    in the k-th set are the indices [i,j] such that i^j=k
+    The function coefficents_for_set returns the matrix entries that are decomposed to the same Pauli strigs set
+    """
+    return [mat[k, k ^ set_index] / len(mat) for k in range(len(mat))]
+
+
+def _get_signed_coefficient(
+    c: complex, k: int, i: int, is_hermitian: bool
+) -> Union[complex, float]:
+    # correct from iY to Y
+    coef = complex((1j) ** ((i & k).bit_count()) * c)
+    if is_hermitian:
+        return coef.real
+    else:
+        return coef
+
+
+def matrix_to_hamiltonian(
+    mat: np.ndarray, tol: float = ATOL, is_hermitian: bool = True
+) -> List[PauliTerm]:
+    """
+    The decomposition per set is done by the Walsh-Hadamard transform,
+    since the transformation between {e_0,e_3} ({e_1,e_2}) to {I,Z} ({X,iY}) is the Hadamard matrix.
+    """
+    mat.shape[0] != 0, "matrix is of size 0"
+    if is_hermitian:
+        assert np.allclose(
+            mat, np.conjugate(mat.T)
+        ), "Matrix is not hermitian, please pass is_hermitian=False"
+    assert mat.shape[0] == mat.shape[1], "Matrix is not square"
+    mat_dimension = mat.shape[0]
+    assert mat_dimension.bit_count() == 1, "Matrix dimension is not a power of 2"
+    num_qubits = (mat_dimension - 1).bit_length()
+    hamiltonian = []
+    for k in range(2**num_qubits):
+        coef = fwht(
+            _coefficents_for_set(mat, k)
+        )  # the transformation per set is given by the Walsh-Hadamard transform
+        hamiltonian += [
+            PauliTerm(
+                pauli=_get_pauli_string(k, i, num_qubits),
+                coefficient=_get_signed_coefficient(coef[i], k, i, is_hermitian),
+            )
+            for i in range(2**num_qubits)
+            if abs(coef[i]) > tol
+        ]
+    return hamiltonian
+
+
+# convert a single puali string of length N to 2**N X 2**N matrix
+def pauli_string_to_mat(seq: List[Pauli]) -> np.ndarray:
+    real_matrix = PAULI_MATRICES_DICT[seq[0]]
+    for p in seq[1:]:
+        real_matrix = np.kron(real_matrix, PAULI_MATRICES_DICT[p])
+    return real_matrix
+
+
+# return matrix from hamiltonian
+def hamiltonian_to_matrix(hamiltonian: List[PauliTerm]) -> np.ndarray:
+    matrix = np.zeros(
+        [2 ** len(hamiltonian[0].pauli), 2 ** len(hamiltonian[0].pauli)],
+        dtype=np.complex_,
+    )
+    for p in hamiltonian:
+        matrix += p.coefficient * pauli_string_to_mat(p.pauli)
+
+    return matrix

classiq/applications/qnn/qlayer.py

@@ -181,6 +181,6 @@ class QLayer(nn.Module):
         self.weight = Parameter(value)
 
     def forward(self, x: Tensor) -> Tensor:
-        return QLayerFunction.apply(  # type: ignore[no-untyped-call]
+        return QLayerFunction.apply(
             x, self.weight, self.quantum_program, self._execute, self._post_process
         )

classiq/exceptions.py

@@ -176,3 +176,7 @@ class ClassiqExecutorInvalidHamiltonianError(ClassiqCombOptError):
 
 class ClassiqSemanticError(ClassiqError):
     pass
+
+
+class ClassiqDeprecationWarning(FutureWarning):
+    pass

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.43.2'
+SEMVER_VERSION = '0.44.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/ast_node.py

@@ -1,4 +1,3 @@
-import os
 from typing import Optional
 
 import pydantic
@@ -6,23 +5,7 @@ import pydantic
 from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
-
-
-class SourceReference(HashablePydanticBaseModel):
-    start_line: int
-    start_column: int
-    end_line: int
-    end_column: int
-    file_name: Optional[str] = pydantic.Field(default=None)
-
-    def __str__(self) -> str:
-        file_string = (
-            f"file {os.path.basename(self.file_name)} " if self.file_name else ""
-        )
-        start_character_string = (
-            f" character {self.start_column + 1}" if self.start_column > 0 else ""
-        )
-        return f"{file_string}line {self.start_line + 1}{start_character_string}"
+from classiq.interface.source_reference import SourceReference
 
 
 class ASTNode(HashablePydanticBaseModel):

classiq/interface/backend/backend_preferences.py

@@ -1,10 +1,9 @@
 from __future__ import annotations
 
-from datetime import timedelta
 from typing import Any, Dict, Iterable, List, Optional, Union
 
 import pydantic
-from pydantic import BaseModel, PrivateAttr, validator
+from pydantic import BaseModel, validator
 
 from classiq.interface.backend import pydantic_backend
 from classiq.interface.backend.quantum_backend_providers import (
@@ -56,9 +55,6 @@ class BackendPreferences(BaseModel):
         return False
 
 
-AWS_DEFAULT_JOB_TIMEOUT_SECONDS = int(timedelta(minutes=240).total_seconds())
-
-
 class AliceBobBackendPreferences(BackendPreferences):
     backend_service_provider: ProviderTypeVendor.ALICE_BOB
     distance: Optional[int] = pydantic.Field(
@@ -76,7 +72,6 @@ class AliceBobBackendPreferences(BackendPreferences):
     api_key: pydantic_backend.PydanticAliceBobApiKeyType = pydantic.Field(
         ..., description="AliceBob API key"
     )
-    _parameters: Dict[str, Any] = PrivateAttr(default_factory=dict)
 
     @pydantic.root_validator(pre=True)
     def _set_backend_service_provider(cls, values: Dict[str, Any]) -> Dict[str, Any]:
@@ -86,14 +81,13 @@ class AliceBobBackendPreferences(BackendPreferences):
 
     @property
     def parameters(self) -> Dict[str, Any]:
-        self._parameters = {
+        parameters = {
             "distance": self.distance,
-            "kappa_1": self.kappa_1,
-            "kappa_2": self.kappa_2,
-            "average_nb_photons": self.average_nb_photons,
+            "kappa1": self.kappa_1,
+            "kappa2": self.kappa_2,
+            "averageNbPhotons": self.average_nb_photons,
         }
-        self._parameters = {k: v for k, v in self._parameters.items() if v is not None}
-        return self._parameters
+        return {k: v for k, v in parameters.items() if v is not None}
 
 
 class ClassiqBackendPreferences(BackendPreferences):
@@ -118,10 +112,6 @@ class AwsBackendPreferences(BackendPreferences):
     s3_folder: pydantic_backend.PydanticS3BucketKey = pydantic.Field(
         description="S3 Folder Path Within The S3 Bucket"
     )
-    job_timeout: pydantic_backend.PydanticExecutionTimeout = pydantic.Field(
-        description="Timeout for Jobs sent for execution in seconds.",
-        default=AWS_DEFAULT_JOB_TIMEOUT_SECONDS,
-    )
 
     @validator("s3_bucket_name")
     def _validate_s3_bucket_name(
@@ -156,6 +146,10 @@ class IBMBackendPreferences(BackendPreferences):
         default_factory=IBMBackendProvider,
         description="Provider specs. for identifying a single IBM Quantum provider.",
     )
+    qctrl_api_key: Optional[str] = pydantic.Field(
+        default=None,
+        description="QCTRL API key to access QCTRL optimization abilities",
+    )
 
     @pydantic.root_validator(pre=True)
     def _set_backend_service_provider(cls, values: Dict[str, Any]) -> Dict[str, Any]:
@@ -191,6 +185,11 @@ class AzureBackendPreferences(BackendPreferences):
         description="The service principal credential to access personal quantum workspace",
     )
 
+    ionq_error_mitigation_flag: Optional[bool] = pydantic.Field(
+        default=False,
+        description="Error mitigation configuration upon running on IonQ through Azure.",
+    )
+
     @property
     def run_through_classiq(self) -> bool:
         return self.credentials is None

classiq/interface/backend/ionq/ionq_quantum_program.py

@@ -37,7 +37,7 @@ class IonqQuantumCircuit(BaseModel):
     circuit: List[Gate]
 
     # Ionq changes format sometimes.
-    #   One example is that `IonqQauntumCircuit` got a field name "gateset" with the value "qis"
+    #   One example is that `IonqQuantumCircuit` got a field name "gateset" with the value "qis"
     #   Another is that `Gate` got a field named "rotation"
     class Config:
         extra = pydantic.Extra.allow

classiq/interface/backend/pydantic_backend.py

@@ -1,4 +1,3 @@
-from datetime import timedelta
 from typing import TYPE_CHECKING
 
 import pydantic
@@ -11,12 +10,10 @@ INVALID_API_KEY: str = _IONQ_API_KEY_LENGTH * "a"
 INVALID_API_KEY_ALICE_BOB: str = _ALICE_BOB_API_KEY_LENGTH * "a"
 INVALID_EMAIL_OQC: str = "aa@aa.aa"
 INVALID_PASSWORD_OQC: str = "Aa1!Aa1!"
-MAX_EXECUTION_TIMEOUT_SECONDS = timedelta(hours=4).total_seconds()
 
 EXECUTION_PARAMETER_PATTERN = "[_a-z][_a-z0-9]*"
 
 if TYPE_CHECKING:
-    PydanticExecutionTimeout = int
     PydanticAwsRoleArn = str
     PydanticS3BucketKey = str
     PydanticS3BucketName = str
@@ -42,8 +39,6 @@ else:
 
     PydanticAliceBobApiKeyType = pydantic.constr(min_length=1, strip_whitespace=True)
 
-    PydanticExecutionTimeout = pydantic.conint(gt=0, le=MAX_EXECUTION_TIMEOUT_SECONDS)
-
     PydanticArgumentNameType = pydantic.constr(regex="[_a-zA-Z][_a-zA-Z0-9]*")
 
     PydanticExecutionParameter = pydantic.constr(regex=EXECUTION_PARAMETER_PATTERN)

classiq/interface/backend/quantum_backend_providers.py

@@ -41,8 +41,9 @@ class ClassiqSimulatorBackendNames(StrEnum):
 class IonqBackendNames(StrEnum):
     SIMULATOR = "simulator"
     HARMONY = "qpu.harmony"
-    ARIA = "qpu.aria-1"
-    S11 = "qpu.s11"
+    ARIA_1 = "qpu.aria-1"
+    ARIA_2 = "qpu.aria-2"
+    FORTE_1 = "qpu.forte-1"
 
 
 class AzureQuantumBackendNames(StrEnum):

classiq/interface/chemistry/operator.py

@@ -140,8 +140,12 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
     def num_qubits(self) -> int:
         return len(self.pauli_list[0][0])
 
+    @property
+    def all_coefficients_numeric(self) -> bool:
+        return all(isinstance(summand[1], complex) for summand in self.pauli_list)
+
     def to_matrix(self) -> np.ndarray:
-        if not all(isinstance(summand[1], complex) for summand in self.pauli_list):
+        if not self.all_coefficients_numeric:
             raise ClassiqValueError(
                 "Supporting only Hamiltonian with numeric coefficients."
             )

classiq/interface/debug_info/debug_info.py

@@ -0,0 +1,32 @@
+from typing import Dict, Optional, Union
+from uuid import UUID
+
+from pydantic import BaseModel, Field
+
+from classiq.interface.ide.visual_model import OperationLevel
+
+
+class FunctionDebugInfo(BaseModel):
+    name: str
+    parameters: Dict[str, Union[int, float, None]]
+    level: OperationLevel
+    is_allocate_or_free: bool = Field(default=False)
+
+
+class DebugInfoCollection(BaseModel):
+    # Pydantic only started supporting UUID as keys in Pydantic V2
+    # See https://github.com/pydantic/pydantic/issues/2096#issuecomment-814860206
+    # For now, we use strings as keys in the raw data and use UUID in the wrapper logic
+    data: Dict[str, FunctionDebugInfo] = Field(default_factory=dict)
+
+    def __setitem__(self, key: UUID, value: FunctionDebugInfo) -> None:
+        self.data[str(key)] = value
+
+    def get(self, key: UUID) -> Optional[FunctionDebugInfo]:
+        return self.data.get(str(key))
+
+    def __getitem__(self, key: UUID) -> FunctionDebugInfo:
+        return self.data[str(key)]
+
+    def __contains__(self, key: UUID) -> bool:
+        return str(key) in self.data