classiq 0.68.0__py3-none-any.whl → 0.70.0__py3-none-any.whl

classiq/_internals/api_wrapper.py

@@ -22,10 +22,6 @@ from classiq.interface.execution.iqcc import (
     IQCCProbeAuthData,
     IQCCProbeAuthResponse,
 )
-from classiq.interface.execution.jobs import (
-    ExecutionJobDetailsV1,
-    ExecutionJobsQueryResultsV1,
-)
 from classiq.interface.execution.primitives import PrimitivesInput
 from classiq.interface.executor import execution_request
 from classiq.interface.generator import quantum_program as generator_result
@@ -218,7 +214,7 @@ class ApiWrapper:
         job_id: JobID,
         name: str,
         http_client: Optional[httpx.AsyncClient] = None,
-    ) -> ExecutionJobDetailsV1:
+    ) -> execution_request.ExecutionJobDetails:
         data = await cls._call_task(
             http_method=HTTPMethod.PATCH,
             url=f"{routes.EXECUTION_JOBS_FULL_PATH}/{job_id.job_id}",
@@ -227,7 +223,7 @@ class ApiWrapper:
             },
             http_client=http_client,
         )
-        return ExecutionJobDetailsV1.model_validate(data)
+        return execution_request.ExecutionJobDetails.model_validate(data)
 
     @classmethod
     async def call_cancel_execution_job(
@@ -248,7 +244,7 @@ class ApiWrapper:
         offset: int,
         limit: int,
         http_client: Optional[httpx.AsyncClient] = None,
-    ) -> ExecutionJobsQueryResultsV1:
+    ) -> execution_request.ExecutionJobsQueryResults:
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
             url=f"{routes.EXECUTION_JOBS_FULL_PATH}",
@@ -258,7 +254,7 @@ class ApiWrapper:
             },
             http_client=http_client,
         )
-        return ExecutionJobsQueryResultsV1.model_validate(data)
+        return execution_request.ExecutionJobsQueryResults.model_validate(data)
 
     @classmethod
     async def call_analysis_task(

classiq/analyzer/analyzer.py

@@ -5,7 +5,6 @@ import webbrowser
 from collections.abc import Sequence
 from importlib.util import find_spec
 from typing import Any, Optional, Union
-from urllib.parse import urljoin
 
 import plotly.graph_objects as go
 
@@ -21,7 +20,6 @@ from classiq.analyzer.analyzer_utilities import (
     DeviceName,
     ProviderNameEnum,
 )
-from classiq.analyzer.url_utils import circuit_page_uri, client_ide_base_url
 
 find_ipywidgets = find_spec("ipywidgets")
 VBox = Any
@@ -63,22 +61,6 @@ class Analyzer(AnalyzerUtilities):
             transpilation_option=self.circuit.model.execution_preferences.transpile_to_hardware,
         )
 
-    def analyzer_app(self) -> None:
-        """Opens the analyzer app with synthesis interactive results.
-
-        Returns:
-            None.
-        """
-        result = async_utils.run(ApiWrapper.call_analyzer_app(self.circuit))
-        webbrowser.open_new_tab(
-            urljoin(
-                client_ide_base_url(),
-                circuit_page_uri(
-                    circuit_id=result.id, circuit_version=self.circuit.version
-                ),
-            )
-        )
-
     def get_available_devices(
         self, providers: Optional[list[ProviderNameEnum]] = None
     ) -> dict[ProviderNameEnum, list[DeviceName]]:

classiq/analyzer/url_utils.py

@@ -7,6 +7,7 @@ import classiq
 
 QUERY_START_MARK = "?"
 VERSION_QUERY_PARAM = "version"
+LOGIN_QUERY_PARAM = "login"
 
 
 def client_ide_base_url() -> str:
@@ -14,13 +15,17 @@ def client_ide_base_url() -> str:
     return str(client.config.ide)
 
 
-def versioned_url_params(circuit_version: str) -> str:
-    return QUERY_START_MARK + urllib.parse.urlencode(
-        {VERSION_QUERY_PARAM: circuit_version}
+def circuit_page_search_params(circuit_version: str) -> str:
+    return urllib.parse.urlencode(
+        {
+            LOGIN_QUERY_PARAM: True,
+            VERSION_QUERY_PARAM: circuit_version,
+        }
     )
 
 
 def circuit_page_uri(circuit_id: str, circuit_version: str) -> str:
     url = urljoin(f"{routes.ANALYZER_CIRCUIT_PAGE}/", circuit_id)
-    url += versioned_url_params(circuit_version=circuit_version)
+    query_string = circuit_page_search_params(circuit_version)
+    url += QUERY_START_MARK + query_string
     return url

classiq/applications/combinatorial_helpers/pyomo_utils.py

@@ -1,3 +1,4 @@
+import copy
 import math
 import re
 from collections import defaultdict
@@ -209,6 +210,7 @@ def convert_pyomo_to_global_presentation(
 def pyomo2qmod(
     struct_name: str, pyo_model: ConcreteModel
 ) -> CombinatorialOptimizationStructDeclaration:
+    pyo_model = copy.deepcopy(pyo_model)
     symbols_map = PyomoSympyBimap()
 
     variables: list[sympy.Symbol] = []

classiq/applications/combinatorial_optimization/combinatorial_problem.py

@@ -24,7 +24,6 @@ from classiq.open_library.functions.utility_functions import (
 from classiq.qmod.builtins.functions import RX
 from classiq.qmod.builtins.operations import allocate, phase, repeat
 from classiq.qmod.cparam import CReal
-from classiq.qmod.create_model_function import create_model
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray
 from classiq.qmod.qmod_variable import Output, QVar
@@ -75,17 +74,15 @@ class CombinatorialProblem:
             hadamard_transform(v)
             repeat(
                 self.num_layers_,
-                lambda i: [  # type:ignore[arg-type]
-                    phase(
-                        -self.cost_func(v), params[i]
-                    ),  # type:ignore[func-returns-value]
+                lambda i: [
+                    phase(-self.cost_func(v), params[i]),
                     apply_to_all(lambda q: RX(params[self.num_layers_ + i], q), v),
                 ],
             )
 
-        self.model_ = create_model(
-            main, constraints=constraints, preferences=preferences
-        )  # type:ignore[assignment]
+        self.model_ = main.create_model(
+            constraints=constraints, preferences=preferences
+        ).get_model()  # type:ignore[assignment]
         return self.model_  # type:ignore[return-value]
 
     def get_qprog(self) -> SerializedQuantumProgram:
@@ -199,13 +196,13 @@ def execute_qaoa(
         hadamard_transform(v)
         repeat(
             num_layers,
-            lambda i: [  # type:ignore[arg-type]
-                phase(-cost_func(v), params[i]),  # type:ignore[func-returns-value]
+            lambda i: [
+                phase(-cost_func(v), params[i]),
                 apply_to_all(lambda q: RX(params[num_layers + i], q), v),
             ],
         )
 
-    model = create_model(main)
+    model = main.create_model().get_model()
     qprog = synthesize(model)
 
     with ExecutionSession(qprog, execution_preferences) as es:

classiq/applications/qnn/gradients/quantum_gradient.py

@@ -18,7 +18,7 @@ class QuantumGradient(abc.ABC):
         execute: ExecuteFunction,
         post_process: PostProcessFunction,
         *args: Any,
-        **kwargs: Any
+        **kwargs: Any,
     ) -> None:
         self._execute = execute
         self._post_process = post_process

classiq/applications/qnn/gradients/simple_quantum_gradient.py

@@ -71,7 +71,7 @@ class SimpleQuantumGradient(QuantumGradient):
         post_process: PostProcessFunction,
         epsilon: float = EPSILON,
         *args: Any,
-        **kwargs: Any
+        **kwargs: Any,
     ) -> None:
         super().__init__(quantum_program, execute, post_process)
         self._epsilon = epsilon

classiq/applications/qnn/torch_utils.py

@@ -94,7 +94,7 @@ def iter_inputs_weights(
     post_process: PostProcessFunction,
     *,
     expected_shape: Shape = (),
-    requires_grad: Optional[bool] = None
+    requires_grad: Optional[bool] = None,
 ) -> Tensor:
     if is_single_layer_circuit(weights):
         iter_weights = torch.reshape(weights, (1, weights.shape[0]))

classiq/execution/jobs.py

@@ -9,7 +9,6 @@ from classiq.interface.exceptions import (
     ClassiqAPIError,
     ClassiqError,
 )
-from classiq.interface.execution.jobs import ExecutionJobDetailsV1
 from classiq.interface.executor.execution_request import ExecutionJobDetails, JobCost
 from classiq.interface.executor.execution_result import ResultsCollection
 from classiq.interface.executor.result import (
@@ -26,8 +25,6 @@ from classiq._internals.async_utils import syncify_function
 from classiq._internals.client import client
 from classiq._internals.jobs import JobID, JobPoller
 
-_JobDetails = Union[ExecutionJobDetails, ExecutionJobDetailsV1]
-
 
 class ClassiqExecutionResultError(ClassiqError):
     def __init__(self, primitive: str) -> None:
@@ -37,10 +34,10 @@ class ClassiqExecutionResultError(ClassiqError):
 
 
 class ExecutionJob:
-    _details: _JobDetails
+    _details: ExecutionJobDetails
     _result: Optional[ResultsCollection]
 
-    def __init__(self, details: _JobDetails) -> None:
+    def __init__(self, details: ExecutionJobDetails) -> None:
         self._details = details
         self._result = None
 

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

classiq/interface/backend/quantum_backend_providers.py

@@ -172,15 +172,20 @@ class ClassiqNvidiaBackendNames(StrEnum):
 
     SIMULATOR = "nvidia_simulator"
     SIMULATOR_STATEVECTOR = "nvidia_simulator_statevector"
+    BRAKET_NVIDIA_SIMULATOR = "braket_nvidia_simulator"
+    BRAKET_NVIDIA_SIMULATOR_STATEVECTOR = "braket_nvidia_simulator_statevector"
+
+    def is_braket_nvidia_backend(self) -> bool:
+        return self in (
+            self.BRAKET_NVIDIA_SIMULATOR,
+            self.BRAKET_NVIDIA_SIMULATOR_STATEVECTOR,
+        )
 
 
 class IntelBackendNames(StrEnum):
     SIMULATOR = "intel_qsdk_simulator"
 
 
-AllClassiqBackendNames = Union[ClassiqSimulatorBackendNames, ClassiqNvidiaBackendNames]
-
-
 class GoogleNvidiaBackendNames(StrEnum):
     """
     Google backend names which Classiq Supports running on.

classiq/interface/chemistry/operator.py

@@ -1,5 +1,6 @@
 from collections.abc import Collection
 from functools import reduce
+from itertools import combinations
 from typing import (
     Any,
     Optional,
@@ -84,31 +85,11 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
             raise ClassiqValueError("Pauli strings have incompatible lengths.")
         return pauli_list
 
-    @staticmethod
-    def check_if_hermitian(pauli_list: PydanticPauliList) -> bool:
-        if all(isinstance(summand[1], (float, int, complex)) for summand in pauli_list):
-            if all(np.isclose(summand[1].imag, 0) for summand in pauli_list):  # type: ignore[union-attr]
-                return True
-
-            for pauli_string, coeff in pauli_list:
-                reverse_string = pauli_string[::-1]
-                reverse_found = False
-                for other_string, other_coeff in pauli_list:
-                    if other_string == reverse_string and np.isclose(
-                        coeff, other_coeff.conjugate()  # type: ignore[union-attr]
-                    ):
-                        reverse_found = True
-                        break
-                if not reverse_found:
-                    return False
-            return True
-        return False
-
     @pydantic.model_validator(mode="before")
     @classmethod
     def _validate_hermitianity(cls, values: dict[str, Any]) -> dict[str, Any]:
         pauli_list = values.get("pauli_list", [])
-        if PauliOperator.check_if_hermitian(pauli_list):
+        if all(isinstance(summand[1], (float, int, complex)) for summand in pauli_list):
             values["is_hermitian"] = all(
                 np.isclose(complex(summand[1]).real, summand[1])
                 for summand in pauli_list
@@ -144,16 +125,19 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
     @property
     def is_commutative(self) -> bool:
         return all(
-            self._is_sub_pauli_commutative(
-                [summand[0][qubit_num] for summand in self.pauli_list]
-            )
-            for qubit_num in range(self.num_qubits)
+            self._do_paulis_commute(first[0], second[0])
+            for first, second in combinations(self.pauli_list, 2)
         )
 
     @staticmethod
-    def _is_sub_pauli_commutative(qubit_pauli_string: Union[list[str], str]) -> bool:
-        unique_paulis = set(qubit_pauli_string) - {"I"}
-        return len(unique_paulis) <= 1
+    def _do_paulis_commute(
+        first: PydanticPauliMonomialStr, second: PydanticPauliMonomialStr
+    ) -> bool:
+        commute = True
+        for c1, c2 in zip(first, second):
+            if (c1 != "I") and (c2 != "I") and (c1 != c2):
+                commute = not commute
+        return commute
 
     @property
     def num_qubits(self) -> int:

classiq/interface/debug_info/back_ref_util.py

@@ -0,0 +1,22 @@
+from classiq.interface.model.allocate import Allocate
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.statement_block import (
+    ConcreteQuantumStatement,
+    StatementBlock,
+)
+
+"""
+This module contains helper functions to determine if a given quantum statement
+ is an allocation or free statement.
+"""
+
+
+def is_allocate_or_free(concrete_quantum_statement: ConcreteQuantumStatement) -> bool:
+    return isinstance(concrete_quantum_statement, Allocate) or (
+        isinstance(concrete_quantum_statement, QuantumFunctionCall)
+        and concrete_quantum_statement.function == "free"
+    )
+
+
+def is_allocate_or_free_by_backref(back_refs: StatementBlock) -> bool:
+    return len(back_refs) > 0 and is_allocate_or_free(back_refs[0])

classiq/interface/debug_info/debug_info.py

@@ -1,34 +1,23 @@
-import json
 from collections.abc import Mapping
-from typing import Any, Optional, Union
+from typing import Optional, Union
 from uuid import UUID
 
 from pydantic import BaseModel, Field
 
-from classiq.interface.enum_utils import StrEnum
+from classiq.interface.debug_info import back_ref_util
 from classiq.interface.generator.generated_circuit_data import (
     FunctionDebugInfoInterface,
     OperationLevel,
+    StatementType,
 )
 from classiq.interface.model.statement_block import ConcreteQuantumStatement
 
 ParameterValue = Union[float, int, str, None]
 
 
-class StatementType(StrEnum):
-    CONTROL = "control"
-    POWER = "power"
-    INVERT = "invert"
-    WITHIN_APPLY = "within_apply"
-    ASSIGNMENT = "assignment"
-    REPEAT = "repeat"
-
-
 class FunctionDebugInfo(BaseModel):
     name: str
-    # Parameters describe classical parameters passed to function
-    parameters: dict[str, str]
-    level: OperationLevel
+    level: OperationLevel = Field(default=OperationLevel.UNKNOWN)
     statement_type: Union[StatementType, None] = None
     is_allocate_or_free: bool = Field(default=False)
     is_inverse: bool = Field(default=False)
@@ -36,12 +25,13 @@ class FunctionDebugInfo(BaseModel):
     port_to_passed_variable_map: dict[str, str] = Field(default_factory=dict)
     node: Optional[ConcreteQuantumStatement] = None
 
-    @staticmethod
-    def param_controller(value: Any) -> str:
-        try:
-            return json.dumps(value)
-        except TypeError:
-            return repr(value)
+    @property
+    def is_allocate_or_free_(self) -> bool:
+        return (
+            back_ref_util.is_allocate_or_free(self.node)
+            if self.node is not None
+            else self.is_allocate_or_free
+        )
 
     def update_map_from_port_mapping(self, port_mapping: Mapping[str, str]) -> None:
         new_port_to_passed_variable_map = self.port_to_passed_variable_map.copy()

classiq/interface/executor/optimizer_preferences.py

@@ -21,6 +21,7 @@ class OptimizerType(StrEnum):
     L_BFGS_B = "L_BFGS_B"
     NELDER_MEAD = "NELDER_MEAD"
     ADAM = "ADAM"
+    SLSQP = "SLSQP"
 
 
 class OptimizerPreferences(BaseModel):

classiq/interface/executor/quantum_instruction_set.py

@@ -6,6 +6,7 @@ class QuantumInstructionSet(StrEnum):
     QASM = "qasm"
     QSHARP = "qsharp"
     IONQ = "ionq"
+    INTERNAL = "_internal"
 
     @classmethod
     def from_suffix(cls, suffix: str) -> "QuantumInstructionSet":

classiq/interface/generator/arith/arithmetic.py

@@ -22,6 +22,9 @@ from classiq.interface.generator.arith.arithmetic_result_builder import (
 )
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.expression_constants import (
+    BOOLEAN_LITERALS,
+)
 from classiq.interface.model.quantum_type import (
     QuantumNumeric,
     QuantumType,
@@ -40,6 +43,10 @@ def is_zero(expr: str) -> bool:
     return is_constant(expr) and float(expr) == 0
 
 
+def is_bool(expr: str) -> bool:
+    return expr in BOOLEAN_LITERALS
+
+
 class Arithmetic(ArithmeticExpressionABC):
     target: Optional[RegisterArithmeticInfo] = None
     inputs_to_save: set[str] = pydantic.Field(default_factory=set)
@@ -115,7 +122,7 @@ def get_arithmetic_params(
 def compute_arithmetic_result_type(
     expr_str: str, var_types: dict[str, QuantumType], machine_precision: int
 ) -> QuantumNumeric:
-    if is_zero(expr_str):
+    if is_zero(expr_str) or is_bool(expr_str):
         return QuantumNumeric(
             size=Expression(expr="1"),
             is_signed=Expression(expr="False"),
@@ -153,6 +160,17 @@ def aggregate_numeric_types(
     )
 
 
+def _eval_num(val: ast.AST) -> float:
+    if isinstance(val, ast.Num):
+        return cast(float, val.value)
+    if isinstance(val, ast.UnaryOp) and isinstance(val.op, ast.USub):
+        return -_eval_num(val.operand)
+    raise ClassiqValueError(
+        "Classical lists with quantum subscripts must contain compile-time classical "
+        "real numbers"
+    )
+
+
 class _QuantumSubscriptRemover(ast.NodeTransformer):
     def __init__(self, machine_precision: int) -> None:
         self._machine_precision = machine_precision
@@ -161,10 +179,7 @@ class _QuantumSubscriptRemover(ast.NodeTransformer):
     def visit_Call(self, node: ast.Call) -> ast.expr:
         if not isinstance(node.func, ast.Name) or node.func.id != "Piecewise":
             return node
-        items = [
-            cast(float, cast(ast.Num, cast(ast.Tuple, arg).elts[0]).value)
-            for arg in node.args
-        ]
+        items = [_eval_num(cast(ast.Tuple, arg).elts[0]) for arg in node.args]
         numeric_types = [
             compute_arithmetic_result_type(str(num), {}, self._machine_precision)
             for num in items
@@ -172,7 +187,7 @@ class _QuantumSubscriptRemover(ast.NodeTransformer):
         unified_numeric_type = register_info_to_quantum_type(
             aggregate_numeric_types(numeric_types)
         )
-        substitution_var_name = f"__lut__{len(self.substitutions_types)}__"
+        substitution_var_name = f"lut__{len(self.substitutions_types)}__"
         self.substitutions_types[substitution_var_name] = unified_numeric_type
         return ast.Name(id=substitution_var_name)
 

classiq/interface/generator/arith/arithmetic_param_getters.py

@@ -59,7 +59,7 @@ def get_params(
     machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None
+    target: Optional[RegisterArithmeticInfo] = None,
 ) -> ArithmeticOperationParams:
     operation = id2op(node_id)
     if target and not operation_allows_target(operation):
@@ -334,7 +334,7 @@ def logical_and_params_getter(
     machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None
+    target: Optional[RegisterArithmeticInfo] = None,
 ) -> ArithmeticOperationParams:
     return LogicalAnd(args=arg, target=target, machine_precision=machine_precision)
 
@@ -344,7 +344,7 @@ def logical_or_params_getter(
     machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None
+    target: Optional[RegisterArithmeticInfo] = None,
 ) -> ArithmeticOperationParams:
     return LogicalOr(args=arg, target=target, machine_precision=machine_precision)
 

classiq/interface/generator/circuit_code/circuit_code.py

@@ -49,6 +49,10 @@ class CircuitCodeInterface(pydantic.BaseModel):
     def qasm_cirq_compatible(self) -> Optional[Code]:
         return self.outputs.get(QuantumFormat.QASM_CIRQ_COMPATIBLE)
 
+    @property
+    def _execution_serialization(self) -> Optional[Code]:
+        return self.outputs.get(QuantumFormat.EXECUTION_SERIALIZATION)
+
     def get_code(self, instruction_set: QuantumInstructionSet) -> Code:
         quantum_format: QuantumFormat = INSTRUCTION_SET_TO_FORMAT[instruction_set]
         code = self.outputs.get(quantum_format)

classiq/interface/generator/circuit_code/types_and_constants.py

@@ -12,6 +12,7 @@ INSTRUCTION_SET_TO_FORMAT: dict[QuantumInstructionSet, QuantumFormat] = {
     QuantumInstructionSet.QASM: QuantumFormat.QASM,
     QuantumInstructionSet.QSHARP: QuantumFormat.QSHARP,
     QuantumInstructionSet.IONQ: QuantumFormat.IONQ,
+    QuantumInstructionSet.INTERNAL: QuantumFormat.EXECUTION_SERIALIZATION,
 }
 VENDOR_TO_INSTRUCTION_SET: dict[Provider, QuantumInstructionSet] = {
     Provider.CLASSIQ: QuantumInstructionSet.QASM,

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -1,5 +1,3 @@
-from classiq.interface.generator.functions.classical_type import CLASSICAL_ATTRIBUTES
-
 SUPPORTED_PYTHON_BUILTIN_FUNCTIONS = {"len", "sum", "print"}
 
 SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS = {
@@ -33,6 +31,7 @@ SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {
     *SUPPORTED_PYTHON_BUILTIN_FUNCTIONS,
 }
 
+CLASSICAL_ATTRIBUTES = {"len", "size", "is_signed", "fraction_digits"}
 SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS_QMOD = (
     SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS - CLASSICAL_ATTRIBUTES
 )

classiq/interface/generator/expressions/expression_types.py

@@ -4,10 +4,15 @@ from sympy import Expr
 from sympy.logic.boolalg import Boolean
 
 from classiq.interface.generator.expressions.handle_identifier import HandleIdentifier
-from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
-from classiq.interface.generator.expressions.qmod_struct_instance import (
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
+from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
+    QmodSizedProxy,
+)
 from classiq.interface.generator.expressions.type_proxy import TypeProxy
 
 RuntimeConstant = Union[
@@ -19,6 +24,7 @@ RuntimeConstant = Union[
     QmodSizedProxy,
     TypeProxy,
     HandleIdentifier,
+    ClassicalProxy,
 ]
 RuntimeExpression = Union[Expr, Boolean]
 ExpressionValue = Union[RuntimeConstant, RuntimeExpression]