classiq 0.75.0__py3-none-any.whl → 0.77.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/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/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/model/handle_binding.py

@@ -355,3 +355,11 @@ ConcreteHandleBinding = Union[
 SubscriptHandleBinding.model_rebuild()
 SlicedHandleBinding.model_rebuild()
 FieldHandleBinding.model_rebuild()
+
+
+class HandlesList(ASTNode):
+    handles: list["GeneralHandle"]
+
+
+GeneralHandle = Union[ConcreteHandleBinding, HandlesList]
+HandlesList.model_rebuild()

classiq/interface/model/model.py

@@ -1,6 +1,6 @@
 from collections import Counter
 from collections.abc import Mapping
-from typing import Any, Literal, NewType, Optional
+from typing import Any, Literal, NewType
 
 import pydantic
 
@@ -9,7 +9,6 @@ from classiq.interface.debug_info.debug_info import DebugInfoCollection
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.constant import Constant
-from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
@@ -103,9 +102,6 @@ class Model(VersionedModel, ASTNode):
     functions_compilation_metadata: dict[str, CompilationMetadata] = pydantic.Field(
         default_factory=dict
     )
-    execution_parameters: Optional[dict[str, ConcreteClassicalType]] = pydantic.Field(
-        default=None, exclude=True
-    )
 
     @property
     def main_func(self) -> NativeFunctionDefinition:
@@ -184,11 +180,12 @@ class Model(VersionedModel, ASTNode):
             )
         return constants
 
-    def dump_no_preferences_and_constraints(self) -> dict[str, Any]:
+    def dump_no_metadata(self) -> dict[str, Any]:
         return self.model_dump(
             exclude={
                 "constraints",
                 "execution_preferences",
                 "preferences",
+                "functions_compilation_metadata",
             },
         )

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_function_call.py

@@ -1,4 +1,5 @@
 from collections.abc import Iterable, Mapping, Sequence
+from itertools import chain
 from typing import (
     Literal,
     Optional,
@@ -15,7 +16,9 @@ from classiq.interface.generator.functions.port_declaration import (
 )
 from classiq.interface.model.handle_binding import (
     ConcreteHandleBinding,
+    GeneralHandle,
     HandleBinding,
+    HandlesList,
 )
 from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
@@ -31,6 +34,7 @@ ArgValue = Union[
     Expression,
     QuantumOperand,
     ConcreteHandleBinding,
+    HandlesList,
 ]
 
 
@@ -146,6 +150,26 @@ class QuantumFunctionCall(QuantumOperation):
             )
         ]
 
+    @property
+    def handles_with_directions(
+        self,
+    ) -> Iterable[tuple[HandleBinding, PortDeclarationDirection]]:
+        return [(handle, param.direction) for handle, param in self.handles_with_params]
+
+    @property
+    def handles_with_params(
+        self,
+    ) -> Iterable[tuple[HandleBinding, AnonPortDeclaration]]:
+        return [
+            (handle, param)
+            for arg, param in zip(
+                self.positional_args, self.func_decl.positional_arg_declarations
+            )
+            if isinstance(param, AnonPortDeclaration)
+            and isinstance(arg, (HandleBinding, HandlesList))
+            for handle in _get_handles(arg)
+        ]
+
     @property
     def params(self) -> list[Expression]:
         return [
@@ -161,7 +185,7 @@ class QuantumFunctionCall(QuantumOperation):
         return [
             param
             for param in self.positional_args
-            if not isinstance(param, (Expression, HandleBinding))
+            if not isinstance(param, (Expression, HandleBinding, HandlesList))
         ]
 
     @property
@@ -224,3 +248,9 @@ class QuantumFunctionCall(QuantumOperation):
             f" for parameter {param_name}" if len(self.positional_args) > 1 else ""
         )
         return f"as an argument{param_text} of function {self.func_name!r}"
+
+
+def _get_handles(var: GeneralHandle) -> Iterable[HandleBinding]:
+    if isinstance(var, HandleBinding):
+        return [var]
+    return chain.from_iterable(_get_handles(item) for item in var.handles)

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/quantum_statement.py

@@ -1,4 +1,4 @@
-from collections.abc import Mapping, Sequence
+from collections.abc import Iterable, Mapping, Sequence
 from dataclasses import dataclass
 from typing import Any, Callable, Optional
 from uuid import UUID, uuid4
@@ -9,6 +9,9 @@ from typing_extensions import Self
 
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.handle_binding import (
     ConcreteHandleBinding,
@@ -90,6 +93,16 @@ class QuantumOperation(QuantumStatement):
     def readable_outputs(self) -> Sequence[HandleMetadata]:
         return [HandleMetadata(handle=handle) for handle in self.outputs]
 
+    @property
+    def handles_with_directions(
+        self,
+    ) -> Iterable[tuple[HandleBinding, PortDeclarationDirection]]:
+        return (
+            [(handle, PortDeclarationDirection.Input) for handle in self.inputs]
+            + [(handle, PortDeclarationDirection.Output) for handle in self.outputs]
+            + [(handle, PortDeclarationDirection.Inout) for handle in self.inouts]
+        )
+
     def set_generative_block(self, block_name: str, py_callable: Callable) -> None:
         self._generative_blocks[block_name] = py_callable
 

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/interface/source_reference.py

@@ -33,11 +33,16 @@ class SourceReference(HashablePydanticBaseModel):
     file_name: Optional[str] = pydantic.Field(default=None)
 
     def __str__(self) -> str:
-        file_string = _prepare_file_string(self.file_name) if self.file_name else ""
+        return f"{self.file_string()}{self.ref_inside_file()}"
+
+    def file_string(self) -> str:
+        return _prepare_file_string(self.file_name) if self.file_name else ""
+
+    def ref_inside_file(self) -> str:
         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}"
+        return f"line {self.start_line + 1}{start_character_string}"
 
 
 class SourceReferencedError(pydantic.BaseModel):

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 (
@@ -56,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,
@@ -63,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:
@@ -169,19 +173,14 @@ def get_field(
     ],
     field: str,
 ) -> ExpressionValue:
-    if isinstance(proxy, AnyClassicalValue):
-        return AnyClassicalValue(f"({proxy}).{field}")
-    if isinstance(proxy, type) and issubclass(proxy, Enum):
-        return getattr(proxy, field)
-    if (
+    if isinstance(proxy, AnyClassicalValue) or (
         isinstance(proxy, Symbol)
         and not isinstance(proxy, QmodSizedProxy)
         and not isinstance(proxy, ClassicalProxy)
     ):
-        raise ClassiqExpansionError(
-            f"Cannot evaluate '{proxy}.{field}': Variable {str(proxy)!r} is not "
-            f"initialized"
-        )
+        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, list):
         if field != "len":
             raise ClassiqExpansionError(
@@ -217,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)
@@ -253,7 +253,7 @@ 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(
@@ -270,7 +270,9 @@ def do_subscript(value: Any, index: Any) -> Any:
             f"{index.size} qubits but the list size is {length} != 2**{index.size}"
         )
     if isinstance(value, ClassicalArrayProxy):
-        return AnyClassicalValue(f"{value}[{index}]")
+        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])],
@@ -286,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,
@@ -300,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

@@ -1,7 +1,7 @@
 import dataclasses
 from collections.abc import Sequence
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Callable
+from typing import TYPE_CHECKING, Callable, Union, cast
 
 from typing_extensions import Self
 
@@ -15,11 +15,13 @@ 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,
 )
 from classiq.interface.model.handle_binding import (
     HandleBinding,
+    HandlesList,
     NestedHandleBinding,
     SlicedHandleBinding,
 )
@@ -132,6 +134,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:
@@ -252,7 +255,7 @@ class CapturedVars:
 
     def _conjugate_direction(
         self,
-        source_direction: PortDirection | bool,
+        source_direction: Union[PortDirection, bool],
         target_direction: PortDirection,
         var_name: str,
     ) -> PortDirection:
@@ -651,12 +654,9 @@ def validate_args_are_not_propagated(
         for handle in captured_vars
         if isinstance(handle, HandleBinding)
     }
-    arg_handles = {
-        demangle_handle(arg) for arg in args if isinstance(arg, HandleBinding)
-    }
     violating_handles = [
         f"{str(arg_handle)!r}"
-        for arg_handle in arg_handles
+        for arg_handle in _get_all_handles(args)
         if any(
             arg_handle.overlaps(captured_handle) for captured_handle in captured_handles
         )
@@ -667,6 +667,18 @@ def validate_args_are_not_propagated(
         )
 
 
+def _get_all_handles(args: Sequence[ArgValue]) -> set[HandleBinding]:
+    arg_handles: set[HandleBinding] = set()
+    for arg in args:
+        if isinstance(arg, HandleBinding):
+            arg_handles.add(demangle_handle(arg))
+        elif isinstance(arg, HandlesList):
+            arg_handles |= set(
+                map(demangle_handle, cast(list[HandleBinding], arg.handles))
+            )
+    return arg_handles
+
+
 def validate_captured_directions(
     captured_vars: CapturedVars, report_outin: bool = True
 ) -> None:

classiq/model_expansions/closure.py

@@ -17,6 +17,7 @@ from classiq.interface.generator.expressions.proxies.classical.classical_struct_
 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,
@@ -43,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):

classiq/model_expansions/evaluators/arg_type_match.py

@@ -27,7 +27,7 @@ from classiq.interface.model.quantum_function_declaration import (
 
 from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.evaluators.type_type_match import check_signature_match
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+from classiq.model_expansions.scope import Evaluated, QuantumVariable
 from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.qmod_parameter import CInt, get_qmod_type
 
@@ -77,7 +77,7 @@ def check_arg_type_match(
 
 
 def _check_qvar_type_match(argument: Any, error_message: str) -> None:
-    if not isinstance(argument, QuantumSymbol):
+    if not isinstance(argument, QuantumVariable):
         raise ClassiqExpansionError(error_message)
 
 

classiq/model_expansions/evaluators/argument_types.py

@@ -7,7 +7,7 @@ from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_function_declaration import AnonPositionalArg
 
 from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+from classiq.model_expansions.scope import Evaluated, QuantumVariable
 
 
 def add_information_from_output_arguments(
@@ -29,7 +29,7 @@ def add_information_from_output_arguments(
         if not isinstance(parameter, AnonPortDeclaration):
             continue
 
-        argument_as_quantum_symbol = argument.as_type(QuantumSymbol)
+        argument_as_quantum_symbol = argument.as_type(QuantumVariable)
 
         if parameter.direction != PortDeclarationDirection.Output:
             continue
@@ -38,6 +38,6 @@ def add_information_from_output_arguments(
             copy_type_information(
                 parameter.quantum_type,
                 argument_as_quantum_symbol.quantum_type,
-                str(argument_as_quantum_symbol.handle),
+                str(argument_as_quantum_symbol),
             )
     return args

classiq/model_expansions/evaluators/classical_expression.py

@@ -5,6 +5,9 @@ from classiq.interface.generator.expressions.evaluated_expression import (
 )
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.expression_types import ExpressionValue
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 from classiq.interface.model.handle_binding import HandleBinding
 
 from classiq.model_expansions.expression_evaluator import evaluate
@@ -19,18 +22,15 @@ def evaluate_classical_expression(expr: Expression, scope: Scope) -> Evaluated:
         if isinstance(evaluated.value, get_args(ExpressionValue))
     } | {
         name: EvaluatedExpression(
-            value=evaluated.value.quantum_type.get_proxy(HandleBinding(name=name))
+            value=(
+                evaluated.value.quantum_type.get_proxy(HandleBinding(name=name))
+                if evaluated.value.quantum_type.is_evaluated
+                else AnyClassicalValue(name)
+            )
         )
         for name, evaluated in all_symbols
         if isinstance(evaluated.value, QuantumSymbol)
-        and evaluated.value.quantum_type.is_evaluated
-    }
-    uninitialized_locals = {
-        name
-        for name, evaluated in all_symbols
-        if isinstance(evaluated.value, QuantumSymbol)
-        and not evaluated.value.quantum_type.is_evaluated
     }
 
-    ret = evaluate(expr, locals_dict, uninitialized_locals)
+    ret = evaluate(expr, locals_dict)
     return Evaluated(value=ret.value)