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

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

classiq/interface/backend/quantum_backend_providers.py

@@ -175,6 +175,12 @@ class ClassiqNvidiaBackendNames(StrEnum):
     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"

classiq/interface/chemistry/operator.py

@@ -85,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

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/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]

classiq/interface/generator/expressions/proxies/classical/classical_array_proxy.py

@@ -0,0 +1,75 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Union
+
+from sympy import Integer
+
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.model.handle_binding import (
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
+
+if TYPE_CHECKING:
+    from classiq.interface.generator.expressions.expression_types import ExpressionValue
+    from classiq.interface.generator.functions.concrete_types import (
+        ConcreteClassicalType,
+    )
+
+
+class ClassicalArrayProxy(NonSymbolicExpr, ClassicalProxy):
+    def __init__(
+        self, handle: HandleBinding, element_type: "ConcreteClassicalType", length: int
+    ) -> None:
+        super().__init__(handle)
+        self._element_type = element_type
+        self._length = length
+
+    @property
+    def fields(self) -> Mapping[str, "ExpressionValue"]:
+        return {"len": self._length}
+
+    @property
+    def type_name(self) -> str:
+        return "Array"
+
+    def __getitem__(self, key: Union[slice, int, Integer]) -> ClassicalProxy:
+        return (
+            self._get_slice(key) if isinstance(key, slice) else self._get_subscript(key)
+        )
+
+    def _get_slice(self, slice_: slice) -> ClassicalProxy:
+        start = int(slice_.start)
+        stop = int(slice_.stop)
+        if start >= stop:
+            raise ClassiqValueError("Array slice has non-positive length")
+        if start < 0 or stop > self._length:
+            raise ClassiqValueError("Array slice is out of bounds")
+        return ClassicalArrayProxy(
+            SlicedHandleBinding(
+                base_handle=self.handle,
+                start=Expression(expr=str(start)),
+                end=Expression(expr=str(stop)),
+            ),
+            self._element_type,
+            stop - start,
+        )
+
+    def _get_subscript(self, index_: Union[int, Integer]) -> ClassicalProxy:
+        index = int(index_)
+        if index < 0:
+            raise ClassiqValueError(
+                "Array index is out of bounds (negative indices are not supported)"
+            )
+        if index >= self._length:
+            raise ClassiqValueError("Array index is out of bounds")
+        return self._element_type.get_classical_proxy(
+            SubscriptHandleBinding(
+                base_handle=self._handle, index=Expression(expr=str(index_))
+            )
+        )

classiq/interface/generator/expressions/proxies/classical/classical_proxy.py

@@ -0,0 +1,26 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from classiq.interface.generator.expressions.expression_types import ExpressionValue
+    from classiq.interface.model.handle_binding import HandleBinding
+
+
+class ClassicalProxy:
+    def __init__(self, handle: "HandleBinding") -> None:
+        self._handle = handle
+
+    @property
+    def handle(self) -> "HandleBinding":
+        return self._handle
+
+    def __str__(self) -> str:
+        return str(self.handle)
+
+    @property
+    def fields(self) -> Mapping[str, "ExpressionValue"]:
+        raise NotImplementedError
+
+    @property
+    def type_name(self) -> str:
+        raise NotImplementedError

classiq/interface/generator/expressions/proxies/classical/classical_scalar_proxy.py

@@ -0,0 +1,32 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any
+
+from sympy import Symbol
+
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.model.handle_binding import HandleBinding
+
+if TYPE_CHECKING:
+    from classiq.interface.generator.expressions.expression_types import ExpressionValue
+    from classiq.interface.generator.functions.classical_type import ClassicalType
+
+
+class ClassicalScalarProxy(Symbol, ClassicalProxy):
+    def __new__(
+        cls, handle: HandleBinding, *args: Any, **assumptions: bool
+    ) -> "ClassicalScalarProxy":
+        return super().__new__(cls, str(handle), **assumptions)
+
+    def __init__(self, handle: HandleBinding, classical_type: "ClassicalType") -> None:
+        super().__init__(handle)
+        self._classical_type = classical_type
+
+    @property
+    def fields(self) -> Mapping[str, "ExpressionValue"]:
+        return {}
+
+    @property
+    def type_name(self) -> str:
+        return type(self._classical_type).__name__

classiq/interface/generator/expressions/proxies/classical/classical_struct_proxy.py

@@ -0,0 +1,31 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING
+
+from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.model.handle_binding import FieldHandleBinding, HandleBinding
+
+if TYPE_CHECKING:
+    from classiq.interface.generator.expressions.expression_types import ExpressionValue
+    from classiq.interface.generator.types.struct_declaration import StructDeclaration
+
+
+class ClassicalStructProxy(NonSymbolicExpr, ClassicalProxy):
+    def __init__(self, handle: HandleBinding, decl: "StructDeclaration") -> None:
+        super().__init__(handle)
+        self._decl = decl
+
+    @property
+    def fields(self) -> Mapping[str, "ExpressionValue"]:
+        return {
+            field_name: field_type.get_classical_proxy(
+                FieldHandleBinding(base_handle=self.handle, field_name=field_name)
+            )
+            for field_name, field_type in self._decl.variables.items()
+        }
+
+    @property
+    def type_name(self) -> str:
+        return f"Struct {self._decl.name}"

classiq/interface/generator/expressions/{qmod_qarray_proxy.py → proxies/quantum/qmod_qarray_proxy.py}

@@ -6,7 +6,9 @@ from sympy import Integer
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
-from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
+    QmodSizedProxy,
+)
 from classiq.interface.model.handle_binding import (
     HandleBinding,
     SlicedHandleBinding,

classiq/interface/generator/expressions/{qmod_qscalar_proxy.py → proxies/quantum/qmod_qscalar_proxy.py}

@@ -4,7 +4,9 @@ from typing import Any
 from sympy import Symbol
 
 from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
+    QmodSizedProxy,
+)
 from classiq.interface.model.handle_binding import HandleBinding
 
 

classiq/interface/generator/expressions/{qmod_qstruct_proxy.py → proxies/quantum/qmod_qstruct_proxy.py}

@@ -2,7 +2,9 @@ from collections.abc import Mapping
 from typing import TYPE_CHECKING
 
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
-from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
+    QmodSizedProxy,
+)
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     HandleBinding,

classiq/interface/generator/functions/classical_type.py

@@ -1,30 +1,31 @@
-from typing import TYPE_CHECKING, Any, Literal, Union
+from typing import TYPE_CHECKING, Any, Literal
 
 import pydantic
 from pydantic import ConfigDict, PrivateAttr
-from sympy import IndexedBase, Symbol
 from typing_extensions import Self
 
 from classiq.interface.ast_node import HashableASTNode
-from classiq.interface.generator.expressions.expression_types import RuntimeExpression
+from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
+    ClassicalArrayProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_scalar_proxy import (
+    ClassicalScalarProxy,
+)
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
+from classiq.interface.model.handle_binding import HandleBinding
 
 if TYPE_CHECKING:
     from classiq.interface.generator.functions.concrete_types import (
         ConcreteClassicalType,
     )
 
-CLASSICAL_ATTRIBUTES = {"len", "size", "is_signed", "fraction_digits"}
-
-NamedSymbol = Union[IndexedBase, Symbol]
-
 
 class ClassicalType(HashableASTNode):
     _is_generative: bool = PrivateAttr(default=False)
 
-    def as_symbolic(self, name: str) -> Union[NamedSymbol, list[NamedSymbol]]:
-        return Symbol(name)
-
     model_config = ConfigDict(extra="forbid")
 
     def __str__(self) -> str:
@@ -38,13 +39,13 @@ class ClassicalType(HashableASTNode):
     def is_generative(self) -> bool:
         return self._is_generative
 
+    def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
+        return ClassicalScalarProxy(handle, self)
+
 
 class Integer(ClassicalType):
     kind: Literal["int"]
 
-    def as_symbolic(self, name: str) -> Symbol:
-        return Symbol(name, integer=True)
-
     @pydantic.model_validator(mode="before")
     @classmethod
     def _set_kind(cls, values: Any) -> dict[str, Any]:
@@ -54,9 +55,6 @@ class Integer(ClassicalType):
 class Real(ClassicalType):
     kind: Literal["real"]
 
-    def as_symbolic(self, name: str) -> Symbol:
-        return Symbol(name, real=True)
-
     @pydantic.model_validator(mode="before")
     @classmethod
     def _set_kind(cls, values: Any) -> dict[str, Any]:
@@ -76,14 +74,14 @@ class ClassicalList(ClassicalType):
     kind: Literal["list"]
     element_type: "ConcreteClassicalType"
 
-    def as_symbolic(self, name: str) -> Symbol:
-        return IndexedBase(name)
-
     @pydantic.model_validator(mode="before")
     @classmethod
     def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "list")
 
+    def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
+        raise NotImplementedError
+
 
 class StructMetaType(ClassicalType):
     kind: Literal["type_proxy"]
@@ -93,20 +91,23 @@ class StructMetaType(ClassicalType):
     def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "type_proxy")
 
+    def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
+        raise NotImplementedError
+
 
 class ClassicalArray(ClassicalType):
     kind: Literal["array"]
     element_type: "ConcreteClassicalType"
     size: pydantic.PositiveInt
 
-    def as_symbolic(self, name: str) -> list:
-        return [self.element_type.as_symbolic(f"{name}_{i}") for i in range(self.size)]
-
     @pydantic.model_validator(mode="before")
     @classmethod
     def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "array")
 
+    def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
+        return ClassicalArrayProxy(handle, self.element_type, self.size)
+
 
 class OpaqueHandle(ClassicalType):
     pass
@@ -148,12 +149,5 @@ class IQAERes(OpaqueHandle):
         return values_with_discriminator(values, "kind", "iqae_result")
 
 
-def as_symbolic(symbols: dict[str, ClassicalType]) -> dict[str, RuntimeExpression]:
-    return {
-        param_name: param_type.as_symbolic(param_name)
-        for param_name, param_type in symbols.items()
-    }
-
-
 class QmodPyObject:
     pass