classiq 0.74.0__py3-none-any.whl → 0.76.0__py3-none-any.whl

classiq/interface/generator/functions/type_qualifier.py

@@ -1,7 +1,22 @@
 from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqInternalExpansionError
 
 
 class TypeQualifier(StrEnum):
     Const = "const"
     QFree = "qfree"
     Quantum = "quantum"
+    Inferred = "inferred"
+
+    @staticmethod
+    def and_(first: "TypeQualifier", second: "TypeQualifier") -> "TypeQualifier":
+        if second is TypeQualifier.Inferred:
+            raise ClassiqInternalExpansionError
+        if first is TypeQualifier.Quantum or second is TypeQualifier.Quantum:
+            return TypeQualifier.Quantum
+        elif first is TypeQualifier.QFree or second is TypeQualifier.QFree:
+            return TypeQualifier.QFree
+        else:
+            if first is not TypeQualifier.Const and second is not TypeQualifier.Const:
+                raise ClassiqInternalExpansionError("Unexpected type qualifiers")
+            return TypeQualifier.Const

classiq/interface/generator/generated_circuit_data.py

@@ -40,6 +40,7 @@ IOQubitMapping: TypeAlias = dict[str, tuple[int, ...]]
 CLASSIQ_HIERARCHY_SEPARATOR: Literal["__"] = "__"
 QASM_SEPARATOR = "_"
 SPLIT_MARKER: str = "part"
+ARITH_ENGINE_PREFIX = "arith_eng__"
 PART_SUFFIX_REGEX = re.compile(
     rf".+{QASM_SEPARATOR}{SPLIT_MARKER}{QASM_SEPARATOR}(\d+)$"
 )
@@ -177,10 +178,8 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
     absolute_qubits: Optional[tuple[int, ...]] = Field(default=None)
     is_basis_gate: Optional[bool] = Field(default=None)
     is_inverse: bool = Field(default=False)
-    is_allocate_or_free: bool = Field(default=False)
     is_unitary: bool = Field(default=True, exclude=True)
     uuid: Optional[UUID] = Field(default=None, exclude=True)
-    level: OperationLevel = Field(default=OperationLevel.UNKNOWN)
     port_to_passed_variable_map: dict[str, str] = Field(default={})
     release_by_inverse: bool = Field(default=False)
     back_refs: StatementBlock = Field(default_factory=list)
@@ -190,16 +189,8 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
     override_debug_info: Optional["FunctionDebugInfoInterface"] = None
 
     @property
-    def is_allocate_or_free_(self) -> bool:
-        """
-        temporary measure to handle the fact that in the current release we do not have
-        the backref, and therefore fallback to the old field of is_allocate_or_free
-        """
-        return (
-            is_allocate_or_free_by_backref(self.back_refs)
-            if bool(self.back_refs)
-            else self.is_allocate_or_free
-        )
+    def is_allocate_or_free(self) -> bool:
+        return is_allocate_or_free_by_backref(self.back_refs)
 
     @property
     def name(self) -> str:
@@ -215,10 +206,8 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
         if isinstance(back_ref, QuantumFunctionCall):
             name = generate_original_function_name(back_ref.func_name)
             if part_match := PART_SUFFIX_REGEX.match(generated_name):
-                suffix = f" [{part_match.group(1)}]"
-            else:
-                suffix = ""
-            return f"{name}{suffix}"
+                name += f" [{part_match.group(1)}]"
+            return name.removeprefix(ARITH_ENGINE_PREFIX)
 
         statement_kind: str = back_ref.kind
         if isinstance(back_ref, ArithmeticOperation):
@@ -230,19 +219,16 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
         return self.back_refs[0] if self.back_refs else None
 
     @property
-    def level_(self) -> OperationLevel:
+    def level(self) -> OperationLevel:
         # Temp fix for currently "supported" statements
         if self.name in {StatementType.CONTROL, StatementType.POWER}:
             return OperationLevel.QMOD_STATEMENT
 
-        back_ref = self.first_back_ref
-        if back_ref is None:
-            # This is the expected behavior for the case where there's not back ref.
-            # We will use it once we can rely on the existence of the back ref in
-            # all expected cases (non-engine calls)
-            # return OperationLevel.ENGINE_FUNCTION_CALL
-            return self.level
-        if isinstance(back_ref, QuantumFunctionCall):
+        if self.first_back_ref is None:
+            # we use ENGINE_FUNCTION_CALL in case where there's not back ref
+            return OperationLevel.ENGINE_FUNCTION_CALL
+
+        if isinstance(self.first_back_ref, QuantumFunctionCall):
             return OperationLevel.QMOD_FUNCTION_CALL
         return OperationLevel.QMOD_STATEMENT
 

classiq/interface/generator/model/preferences/preferences.py

@@ -102,6 +102,13 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
         debug_mode (bool): If `True`, debug information is added to the
             synthesized result, potentially slowing down the synthesis. Useful for
             executing interactive algorithms. Defaults to `True`.
+        optimization_level (OptimizationLevel) : The optimization level used during synthesis (0-3);
+        determines the trade-off between synthesis speed and the quality of the results. Defaults to 3.
+             OptimizationLevel Options:
+                - NONE = 0
+                - LIGHT = 1
+                - MEDIUM = 2
+                - HIGH = 3
         output_format (List[QuantumFormat]): Lists the output format(s)
             for the quantum circuit. Defaults to `[QuantumFormat.QASM]`.
             `QuantumFormat` Options:

classiq/interface/generator/quantum_program.py

@@ -1,11 +1,9 @@
 import uuid
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import Optional, Union
 
 import pydantic
-from pydantic import model_validator
-from pydantic_core.core_schema import ValidationInfo
 from typing_extensions import TypeAlias
 
 from classiq.interface.compression_utils import decompress
@@ -39,8 +37,6 @@ from classiq.interface.ide.visual_model import CircuitMetrics
 RegisterName: TypeAlias = str
 InitialConditions: TypeAlias = dict[RegisterName, int]
 
-OMIT_DEBUG_INFO_FLAG = "omit_debug_info"
-
 
 class TranspiledCircuitData(CircuitCodeInterface):
     depth: int
@@ -77,18 +73,8 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
     program_id: str = pydantic.Field(default_factory=get_uuid_as_str)
     execution_primitives_input: Optional[PrimitivesInput] = pydantic.Field(default=None)
 
-    @model_validator(mode="before")
-    @classmethod
-    def remove_debug_info(
-        cls, data: dict[str, Any], info: ValidationInfo
-    ) -> dict[str, Any]:
-        if (
-            isinstance(data, dict)
-            and info.context is not None
-            and info.context.get(OMIT_DEBUG_INFO_FLAG, False)
-        ):
-            data.pop("debug_info", None)
-        return data
+    def __str__(self) -> str:
+        return self.model_dump_json(indent=2)
 
     def _hardware_agnostic_program_code(self) -> CodeAndSyntax:
         circuit_code = self.program_circuit.get_code_by_priority()
@@ -177,7 +163,7 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
             file.write(self.model_dump_json(indent=4))
 
     @classmethod
-    def from_qprog(cls, qprog: str) -> "QuantumProgram":
+    def from_qprog(cls, qprog: "QuantumProgram") -> "QuantumProgram":
         """
         Creates a `QuantumProgram` instance from a raw quantum program string.
 
@@ -187,7 +173,7 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
         Returns:
             QuantumProgram: The `QuantumProgram` instance.
         """
-        return cls.model_validate_json(qprog)
+        return qprog
 
     @property
     def _can_use_transpiled_code(self) -> bool:

classiq/interface/generator/synthesis_metadata/synthesis_execution_data.py

@@ -1,10 +1,10 @@
+from itertools import chain
 from typing import Optional
 
 import pydantic
 import sympy
 
 from classiq.interface.backend.pydantic_backend import PydanticExecutionParameter
-from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.parameters import ParameterType
 
 
@@ -12,15 +12,10 @@ class FunctionExecutionData(pydantic.BaseModel):
     power_parameter: Optional[ParameterType] = pydantic.Field(default=None)
 
     @property
-    def power_var(self) -> Optional[str]:
+    def power_vars(self) -> Optional[list[str]]:
         if self.power_parameter is None:
             return None
-        power_vars = sympy.sympify(self.power_parameter).free_symbols
-        if len(power_vars) != 1:
-            raise ClassiqValueError(
-                f"Power parameter expression: {self.power_parameter} must contain exactly one variable"
-            )
-        return str(list(power_vars)[0])
+        return list(map(str, sympy.sympify(self.power_parameter).free_symbols))
 
 
 class ExecutionData(pydantic.BaseModel):
@@ -32,8 +27,10 @@ class ExecutionData(pydantic.BaseModel):
     def execution_parameters(
         self,
     ) -> set[PydanticExecutionParameter]:
-        return {
-            function_execution_data.power_var
-            for function_execution_data in self.function_execution.values()
-            if function_execution_data.power_var is not None
-        }
+        return set(
+            chain.from_iterable(
+                function_execution_data.power_vars
+                for function_execution_data in self.function_execution.values()
+                if function_execution_data.power_vars is not None
+            )
+        )

classiq/interface/helpers/backward_compatibility.py

@@ -0,0 +1,9 @@
+import sys
+from typing import Any
+
+if sys.version_info[0:2] >= (3, 10):
+    zip_strict = zip
+else:
+
+    def zip_strict(*iterables: Any, strict: bool = False) -> zip:
+        return zip(*iterables)

classiq/interface/helpers/datastructures.py

@@ -17,6 +17,12 @@ class LenList(list):
     def len(self) -> int:
         return len(self)
 
+    def __getitem__(self, item: Any) -> Any:
+        res = super().__getitem__(item)
+        if isinstance(item, slice):
+            res = type(self)(res)
+        return res
+
 
 def get_sdk_compatible_python_object(obj: Any) -> Any:
     if isinstance(obj, list):

classiq/interface/helpers/versioned_model.py

@@ -1,7 +1,19 @@
+from typing import Any
+
 import pydantic
 
 from classiq.interface._version import VERSION
+from classiq.interface.interface_version import INTERFACE_VERSION
 
 
 class VersionedModel(pydantic.BaseModel):
     version: str = pydantic.Field(default=VERSION)
+    interface_version: str = pydantic.Field(default="0")
+
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def set_interface_version(cls, values: dict[str, Any]) -> dict[str, Any]:
+        # We "override" the default value mechanism so that the schema does not depend on the version
+        if "interface_version" not in values:
+            values["interface_version"] = INTERFACE_VERSION
+        return values

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "9"
+INTERFACE_VERSION = "10"

classiq/interface/model/handle_binding.py

@@ -67,6 +67,9 @@ class HandleBinding(ASTNode):
     def is_constant(self) -> bool:
         return True
 
+    def expressions(self) -> list[Expression]:
+        return []
+
 
 class NestedHandleBinding(HandleBinding):
     base_handle: "ConcreteHandleBinding"
@@ -111,6 +114,9 @@ class NestedHandleBinding(HandleBinding):
     def is_constant(self) -> bool:
         return self.base_handle.is_constant()
 
+    def expressions(self) -> list[Expression]:
+        return self.base_handle.expressions()
+
 
 class SubscriptHandleBinding(NestedHandleBinding):
     index: Expression
@@ -191,6 +197,9 @@ class SubscriptHandleBinding(NestedHandleBinding):
             and self.index.is_constant()
         )
 
+    def expressions(self) -> list[Expression]:
+        return super().expressions() + [self.index]
+
 
 class SlicedHandleBinding(NestedHandleBinding):
     start: Expression
@@ -305,6 +314,9 @@ class SlicedHandleBinding(NestedHandleBinding):
             and self.end.is_constant()
         )
 
+    def expressions(self) -> list[Expression]:
+        return super().expressions() + [self.start, self.end]
+
 
 class FieldHandleBinding(NestedHandleBinding):
     field: str

classiq/interface/model/port_declaration.py

@@ -16,8 +16,7 @@ from classiq.interface.model.parameter import Parameter
 class AnonPortDeclaration(Parameter):
     quantum_type: ConcreteQuantumType
     direction: PortDeclarationDirection
-    # TODO remove default after BWC-breaking version
-    type_qualifier: TypeQualifier = pydantic.Field(default=TypeQualifier.Quantum)
+    type_qualifier: TypeQualifier
     kind: Literal["PortDeclaration"]
 
     @pydantic.model_validator(mode="before")

classiq/interface/model/quantum_lambda_function.py

@@ -5,6 +5,7 @@ import pydantic
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.helpers.backward_compatibility import zip_strict
 from classiq.interface.model.quantum_function_declaration import (
     AnonQuantumOperandDeclaration,
 )
@@ -56,7 +57,7 @@ class QuantumLambdaFunction(ASTNode):
     def named_func_decl(self) -> AnonQuantumOperandDeclaration:
         named_params = [
             param.rename(rename)
-            for param, rename in zip(
+            for param, rename in zip_strict(
                 self.func_decl.positional_arg_declarations,
                 self.pos_rename_params,
                 strict=False,  # strict=False enables lambda keyword args

classiq/interface/model/statement_block.py

@@ -24,7 +24,12 @@ from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
-from classiq.interface.model.within_apply_operation import WithinApply
+from classiq.interface.model.within_apply_operation import (
+    Action,
+    Compute,
+    Uncompute,
+    WithinApply,
+)
 
 ConcreteQuantumStatement = Annotated[
     Union[
@@ -43,6 +48,9 @@ ConcreteQuantumStatement = Annotated[
         WithinApply,
         PhaseOperation,
         Block,
+        Compute,
+        Action,
+        Uncompute,
     ],
     Field(..., discriminator="kind"),
 ]

classiq/interface/model/within_apply_operation.py

@@ -15,3 +15,15 @@ class WithinApply(QuantumOperation):
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["compute", "action"])
+
+
+class Compute(QuantumOperation):
+    kind: Literal["Compute"]
+
+
+class Action(QuantumOperation):
+    kind: Literal["Action"]
+
+
+class Uncompute(QuantumOperation):
+    kind: Literal["Uncompute"]

classiq/interface/server/routes.py

@@ -6,6 +6,8 @@ CONVERSION_PREFIX = "/conversion"
 PROVIDERS_PREFIX = "/providers"
 
 IQCC_PREFIX = PROVIDERS_PREFIX + "/iqcc"
+USER_BUDGETS_PREFIX = "/user_budgets"
+
 
 ANALYZER_CIRCUIT_PAGE = "circuit"
 DEFAULT_IDE_FE_APP = "https://platform.classiq.io/"
@@ -50,6 +52,7 @@ TASK_TEST_SUFFIX = TASKS_SUFFIX + "/test"
 TASK_PREDICT_SUFFIX = TASKS_SUFFIX + "/predict"
 TASK_RB_SUFFIX = TASKS_SUFFIX + RB
 TASKS_GENERATE_FULL_PATH = TASKS_GENERATE_SUFFIX
+TASKS_VISUAL_MODEL_FULL_PATH = ANALYZER_PREFIX + TASKS_VISUAL_MODEL_SUFFIX
 
 EXECUTION_JOBS_SUFFIX = "/jobs"
 EXECUTION_JOBS_FULL_PATH = EXECUTION_PREFIX + EXECUTION_JOBS_SUFFIX
@@ -80,3 +83,6 @@ IQCC_LIST_AUTH_METHODS_SUFFIX = "/auth_methods"
 IQCC_LIST_AUTH_METHODS_FULL_PATH = IQCC_PREFIX + IQCC_LIST_AUTH_METHODS_SUFFIX
 IQCC_LIST_AUTH_TARGETS_SUFFIX = "/auth_targets"
 IQCC_LIST_AUTH_TARGETS_FULL_PATH = IQCC_PREFIX + IQCC_LIST_AUTH_TARGETS_SUFFIX
+
+USER_BUDGETS_SUFFIX = "/all"
+USER_BUDGETS_FULL_PATH = USER_BUDGETS_PREFIX + USER_BUDGETS_SUFFIX

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -2,6 +2,7 @@ from collections.abc import Mapping
 from enum import Enum
 from typing import Any, Callable, Union, get_args
 
+import sympy
 from sympy import Eq, Expr, Piecewise, Symbol
 
 from classiq.interface.exceptions import (
@@ -15,6 +16,9 @@ from classiq.interface.generator.expressions.expression_types import (
 from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
     AnyClassicalValue,
 )
+from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
+    ClassicalArrayProxy,
+)
 from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
     ClassicalProxy,
 )
@@ -53,6 +57,8 @@ from classiq.model_expansions.sympy_conversion.arithmetics import (
     BitwiseOr,
     BitwiseXor,
     LogicalXor,
+    LShift,
+    RShift,
 )
 from classiq.model_expansions.sympy_conversion.expression_to_sympy import (
     MISSING_SLICE_VALUE_PLACEHOLDER,
@@ -60,11 +66,12 @@ from classiq.model_expansions.sympy_conversion.expression_to_sympy import (
 from classiq.model_expansions.sympy_conversion.sympy_to_python import (
     sympy_to_python,
 )
-from classiq.model_expansions.utils.sympy_utils import (
-    is_constant_subscript,
-    unwrap_sympy_numeric,
+from classiq.model_expansions.utils.sympy_utils import is_constant_subscript
+from classiq.qmod.builtins.classical_functions import (
+    __all__ as qmod_classical_functions,
 )
 from classiq.qmod.model_state_container import QMODULE
+from classiq.qmod.utilities import qmod_val_to_expr_str
 
 
 def qmod_val_to_python(val: ExpressionValue, qmod_type: ClassicalType) -> Any:
@@ -166,15 +173,14 @@ def get_field(
     ],
     field: str,
 ) -> ExpressionValue:
-    if isinstance(proxy, AnyClassicalValue):
-        return AnyClassicalValue(f"({proxy}).{field}")
+    if isinstance(proxy, AnyClassicalValue) or (
+        isinstance(proxy, Symbol)
+        and not isinstance(proxy, QmodSizedProxy)
+        and not isinstance(proxy, ClassicalProxy)
+    ):
+        return AnyClassicalValue(f"get_field({qmod_val_to_expr_str(proxy)}, '{field}')")
     if isinstance(proxy, type) and issubclass(proxy, Enum):
         return getattr(proxy, field)
-    if isinstance(proxy, Symbol) and not isinstance(proxy, QmodSizedProxy):
-        raise ClassiqExpansionError(
-            f"Cannot evaluate '{proxy}.{field}': Variable {str(proxy)!r} is not "
-            f"initialized"
-        )
     if isinstance(proxy, list):
         if field != "len":
             raise ClassiqExpansionError(
@@ -210,9 +216,10 @@ def get_type(struct_type: Symbol) -> TypeProxy:
 
 
 def do_div(lhs: Any, rhs: Any) -> Any:
-    lhs = unwrap_sympy_numeric(lhs)
-    rhs = unwrap_sympy_numeric(rhs)
-    return lhs / rhs
+    res = lhs / rhs
+    if isinstance(res, sympy.Expr):
+        res = res.evalf()
+    return res
 
 
 _EXPRESSION_TYPES = get_args(ExpressionValue)
@@ -229,7 +236,9 @@ def _is_qmod_value(val: Any) -> bool:
 
 
 def do_subscript(value: Any, index: Any) -> Any:
-    if not isinstance(value, list) or not isinstance(index, QmodQNumProxy):
+    if not isinstance(value, (list, ClassicalArrayProxy)) or not isinstance(
+        index, QmodQNumProxy
+    ):
         if isinstance(index, (QmodSizedProxy, QmodStructInstance)):
             raise ClassiqExpansionError(
                 f"Subscript {value}[{index}] is not supported. Supported subscripts "
@@ -244,22 +253,31 @@ def do_subscript(value: Any, index: Any) -> Any:
             and not is_constant_subscript(index)
             and _is_qmod_value(index)
         ):
-            return AnyClassicalValue(str(value))[index]
+            return AnyClassicalValue(qmod_val_to_expr_str(value))[index]
         return value[index]
     if index.is_signed or index.fraction_digits > 0:
         raise ClassiqExpansionError(
             "Quantum numeric subscript must be an unsigned integer (is_signed=False, "
             "fraction_digits=0)"
         )
-    if len(value) != 2**index.size:
+    if isinstance(value, ClassicalArrayProxy):
+        length = value.length
+    else:
+        length = len(value)
+    if length != 2**index.size:
         raise ClassiqExpansionError(
             f"Quantum numeric subscript size mismatch: The quantum numeric has "
-            f"{index.size} qubits but the list size is {len(value)} != 2**{index.size}"
+            f"{index.size} qubits but the list size is {length} != 2**{index.size}"
+        )
+    if isinstance(value, ClassicalArrayProxy):
+        return AnyClassicalValue(
+            f"do_subscript({qmod_val_to_expr_str(value)}, {qmod_val_to_expr_str(index)})"
+        )
+    else:
+        return Piecewise(
+            *[(item, Eq(index, idx)) for idx, item in enumerate(value[:-1])],
+            (value[-1], True),
         )
-    return Piecewise(
-        *[(item, Eq(index, idx)) for idx, item in enumerate(value[:-1])],
-        (value[-1], True),
-    )
 
 
 def do_slice(value: Any, lower: Any, upper: Any) -> Any:
@@ -270,9 +288,29 @@ def do_slice(value: Any, lower: Any, upper: Any) -> Any:
     return do_subscript(value, slice(lower, upper))
 
 
+def do_sum(val: Any) -> Any:
+    if isinstance(val, AnyClassicalValue):
+        return AnyClassicalValue(f"sum({val})")
+    return sum(val)
+
+
+do_sum.__name__ = "sum"
+
+
+def mod_inverse(a: Any, b: Any) -> Any:
+    if (
+        isinstance(a, AnyClassicalValue)
+        or (isinstance(a, sympy.Basic) and len(a.free_symbols) > 0)
+        or isinstance(b, AnyClassicalValue)
+        or (isinstance(b, sympy.Basic) and len(b.free_symbols) > 0)
+    ):
+        return AnyClassicalValue(f"mod_inverse({a}, {b})")
+    return sympy.mod_inverse(a, b)
+
+
 CORE_LIB_FUNCTIONS_LIST: list[Callable] = [
     print,
-    sum,
+    do_sum,
     struct_literal,
     get_field,
     get_type,
@@ -284,8 +322,29 @@ CORE_LIB_FUNCTIONS_LIST: list[Callable] = [
     BitwiseNot,
     BitwiseOr,
     LogicalXor,
+    RShift,
+    LShift,
+    mod_inverse,
+]
+
+
+def _symbolic_function(func: str) -> Callable:
+    def wrapper(*args: Any) -> AnyClassicalValue:
+        return AnyClassicalValue(
+            f"{func}({', '.join(map(qmod_val_to_expr_str, args))})"
+        )
+
+    wrapper.__name__ = func
+    return wrapper
+
+
+QMOD_CLASSICAL_FUNCTIONS = [
+    _symbolic_function(func) for func in qmod_classical_functions
 ]
 
 ATOMIC_EXPRESSION_FUNCTIONS = {
-    **{core_func.__name__: core_func for core_func in CORE_LIB_FUNCTIONS_LIST},
+    **{
+        core_func.__name__: core_func
+        for core_func in CORE_LIB_FUNCTIONS_LIST + QMOD_CLASSICAL_FUNCTIONS
+    },
 }

classiq/model_expansions/capturing/captured_vars.py

@@ -15,6 +15,7 @@ from classiq.interface.generator.functions.classical_type import ClassicalType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -132,6 +133,7 @@ class _CapturedHandle(_Captured):
             name=self.mangled_name,
             quantum_type=self.quantum_type,
             direction=self.direction.dump(),
+            type_qualifier=TypeQualifier.Inferred,  # TODO https://classiq.atlassian.net/browse/CLS-1830
         )
 
     def is_same_var(self, other: "_CapturedHandle") -> bool:

classiq/model_expansions/closure.py

@@ -8,6 +8,16 @@ from typing import Any, Optional
 from typing_extensions import Self
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_struct_proxy import (
+    ClassicalStructProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.utils import (
+    get_proxy_type,
+)
+from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
@@ -34,6 +44,10 @@ class Closure:
     positional_arg_declarations: Sequence[PositionalArg] = tuple()
     captured_vars: CapturedVars = field(default_factory=CapturedVars)
 
+    @property
+    def parameters_dict(self) -> dict[str, PositionalArg]:
+        return nameables_to_dict(self.positional_arg_declarations)
+
 
 @dataclass(frozen=True)
 class GenerativeClosure(Closure):
@@ -139,6 +153,10 @@ def _evaluated_arg_to_str(arg: Any) -> str:
         return _evaluated_one_operand_to_str(arg)
     if isinstance(arg, list) and arg and isinstance(arg[0], FunctionClosure):
         return _evaluated_operands_list_to_str(arg)
+    if isinstance(arg, ClassicalProxy):
+        if isinstance(arg, ClassicalStructProxy):
+            return repr(arg.struct_declaration)
+        return repr(get_proxy_type(arg))
     return evaluated_classical_param_to_str(arg)
 
 

classiq/model_expansions/evaluators/argument_types.py

@@ -34,9 +34,10 @@ def add_information_from_output_arguments(
         if parameter.direction != PortDeclarationDirection.Output:
             continue
 
-        copy_type_information(
-            parameter.quantum_type,
-            argument_as_quantum_symbol.quantum_type,
-            str(argument_as_quantum_symbol.handle),
-        )
+        if parameter.quantum_type.is_evaluated:
+            copy_type_information(
+                parameter.quantum_type,
+                argument_as_quantum_symbol.quantum_type,
+                str(argument_as_quantum_symbol.handle),
+            )
     return args