classiq 0.80.0__py3-none-any.whl → 0.81.0__py3-none-any.whl

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

classiq/interface/debug_info/debug_info.py

@@ -23,7 +23,6 @@ class FunctionDebugInfo(BaseModel):
     name: str
     statement_type: Union[StatementType, None] = None
     is_inverse: bool = Field(default=False)
-    release_by_inverse: bool = Field(default=False)
     control_variable: Optional[str] = Field(default=None)
     port_to_passed_variable_map: dict[str, str] = Field(default_factory=dict)
     node: Optional[ConcreteQuantumStatement] = None

classiq/interface/generator/compiler_keywords.py

@@ -1,7 +1,7 @@
 EXPANDED_KEYWORD = "expanded__"
 CAPTURE_SUFFIX = "_captured__"
 LAMBDA_KEYWORD = "lambda__"
-INPLACE_ARITH_AUX_VAR_PREFIX = "result__temp__"
+INPLACE_ARITH_AUX_VAR_PREFIX = "_tmp"
 
 
 def generate_original_function_name(name: str) -> str:

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -1,20 +1,24 @@
 SUPPORTED_PYTHON_BUILTIN_FUNCTIONS = {"len", "sum", "print"}
 
-SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS = {
-    "do_div",
-    "do_slice",
-    "do_subscript",
+CLASSIQ_BUILTIN_CLASSICAL_FUNCTIONS = {
     "hypercube_entangler_graph",
     "grid_entangler_graph",
     "qft_const_adder_phase",
     "log_normal_finance_post_process",
     "gaussian_finance_post_process",
-    "get_type",
-    "struct_literal",
-    "get_field",
     "molecule_problem_to_hamiltonian",
     "fock_hamiltonian_problem_to_hamiltonian",
     "molecule_ground_state_solution_post_process",
+}
+
+SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS = {
+    *CLASSIQ_BUILTIN_CLASSICAL_FUNCTIONS,
+    "do_div",
+    "do_slice",
+    "do_subscript",
+    "get_type",
+    "struct_literal",
+    "get_field",
     "mod_inverse",
 }
 

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

@@ -64,8 +64,8 @@ class ClassicalSequenceProxy(NonSymbolicExpr, ClassicalProxy):
         if _is_int(start_) and _is_int(stop_):
             start = int(start_)
             stop = int(stop_)
-            if start >= stop:
-                raise ClassiqIndexError("Array slice has non-positive length")
+            if start > stop:
+                raise ClassiqIndexError("Array slice has negative length")
             if start < 0 or (isinstance(self.length, int) and stop > self.length):
                 raise ClassiqIndexError("Array slice is out of bounds")
         return self.get_slice_at(start_, stop_)
@@ -84,6 +84,10 @@ class ClassicalSequenceProxy(NonSymbolicExpr, ClassicalProxy):
                 )
             if isinstance(self.length, int) and index >= self.length:
                 raise ClassiqIndexError("Array index is out of bounds")
+        if isinstance(index_, tuple):
+            raise ClassiqIndexError(
+                "list indices must be integers or slices, not tuple"
+            )
         return self.get_subscript_at(index_)
 
     def get_subscript_at(self, index: Any) -> ClassicalProxy:

classiq/interface/generator/function_params.py

@@ -47,7 +47,7 @@ END_BAD_REGISTER_ERROR_MSG = (
 )
 
 ALPHANUM_AND_UNDERSCORE = r"[0-9a-zA-Z_]*"
-NAME_REGEX = rf"[a-zA-Z]{ALPHANUM_AND_UNDERSCORE}"
+NAME_REGEX = rf"_?[a-zA-Z]{ALPHANUM_AND_UNDERSCORE}"
 
 _UNVALIDATED_FUNCTIONS = ["Arithmetic", "CustomFunction"]
 

classiq/interface/generator/functions/classical_type.py

@@ -316,3 +316,11 @@ class IQAERes(OpaqueHandle):
 
 class QmodPyObject:
     pass
+
+
+CLASSICAL_ATTRIBUTES_TYPES = {
+    "len": Integer(),
+    "size": Integer(),
+    "is_signed": Bool(),
+    "fraction_digits": Integer(),
+}

classiq/interface/generator/generated_circuit_data.py

@@ -54,7 +54,7 @@ VISUALIZATION_HIDE_LIST = [
     "stmt_block",
 ]
 
-CONTROLLED_PREFIX = "c-"
+CONTROLLED_PREFIX = "c_"
 
 
 def last_name_in_call_hierarchy(name: str) -> str:
@@ -189,7 +189,6 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
     is_unitary: bool = Field(default=True, exclude=True)
     uuid: Optional[UUID] = Field(default=None, exclude=True)
     port_to_passed_variable_map: dict[str, str] = Field(default={})
-    release_by_inverse: bool = Field(default=False)
     back_refs: StatementBlock = Field(default_factory=list)
 
     model_config = ConfigDict(extra="allow")

classiq/interface/generator/types/compilation_metadata.py

@@ -4,4 +4,7 @@ from pydantic import BaseModel, Field, NonNegativeInt
 class CompilationMetadata(BaseModel):
     should_synthesize_separately: bool = Field(default=False)
     occurrences_number: NonNegativeInt = Field(default=1)
-    atomic_qualifiers: list[str] = Field(default_factory=list)
+    unchecked: list[str] = Field(default_factory=list)
+    atomic_qualifiers: list[str] = Field(
+        default_factory=list, exclude=True
+    )  # TODO remove after deprecation https://classiq.atlassian.net/browse/CLS-2671

classiq/interface/model/handle_binding.py

@@ -12,6 +12,12 @@ from classiq.interface.generator.expressions.expression import Expression
 HANDLE_ID_SEPARATOR = "___"
 
 
+def _get_expr_id(expr: Expression) -> str:
+    if expr.expr.isidentifier() or expr.expr.isnumeric():
+        return expr.expr
+    return str(abs(hash(expr.expr)))
+
+
 class HandleBinding(ASTNode):
     name: str = Field(default=None)
     model_config = ConfigDict(frozen=True, extra="forbid")
@@ -131,7 +137,10 @@ class SubscriptHandleBinding(NestedHandleBinding):
 
     @property
     def identifier(self) -> str:
-        return f"{self.base_handle.identifier}{HANDLE_ID_SEPARATOR}{self.index}"
+        return (
+            f"{self.base_handle.identifier}{HANDLE_ID_SEPARATOR}"
+            f"{_get_expr_id(self.index)}"
+        )
 
     def collapse(self) -> HandleBinding:
         if isinstance(self.base_handle, SlicedHandleBinding):
@@ -216,7 +225,8 @@ class SlicedHandleBinding(NestedHandleBinding):
     @property
     def identifier(self) -> str:
         return (
-            f"{self.base_handle.identifier}{HANDLE_ID_SEPARATOR}{self.start}_{self.end}"
+            f"{self.base_handle.identifier}{HANDLE_ID_SEPARATOR}"
+            f"{_get_expr_id(self.start)}_{_get_expr_id(self.end)}"
         )
 
     def collapse(self) -> HandleBinding:

classiq/interface/model/quantum_type.py

@@ -5,7 +5,10 @@ from pydantic import BaseModel, ConfigDict, Field
 from typing_extensions import Self
 
 from classiq.interface.ast_node import HashableASTNode
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import (
+    ClassiqInternalExpansionError,
+    ClassiqValueError,
+)
 from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.arith.register_user_input import (
     RegisterArithmeticInfo,
@@ -214,6 +217,14 @@ class QuantumNumeric(QuantumScalar):
             )
         return self
 
+    def set_size_in_bits(self, val: int) -> None:
+        super().set_size_in_bits(val)
+        if self.size is not None:
+            if self.size.is_evaluated() and self.size.value == val:
+                return
+            raise ClassiqInternalExpansionError("Numeric size mismatch")
+        self.size = Expression(expr=str(val))
+
     @property
     def has_sign(self) -> bool:
         return self.is_signed is not None

classiq/interface/server/routes.py

@@ -65,7 +65,6 @@ ASSIGN_PARAMETERS_FULL_PATH = QUANTUM_PROGRAM_PREFIX + ASSIGN_PARAMETERS_SUFFIX
 
 ANALYZER_FULL_PATH = ANALYZER_PREFIX + TASKS_SUFFIX
 ANALYZER_RB_FULL_PATH = ANALYZER_PREFIX + TASK_RB_SUFFIX
-GENERATE_RESOURCE_ESTIMATOR_REPORT = "/resource_estimator_report"
 
 TASKS_SOLVE_EXACT_SUFFIX = "/tasks/solve_exact"
 

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -284,7 +284,7 @@ def do_subscript(value: Any, index: Any) -> Any:
         length = value.length
     else:
         length = len(value)
-    if length != 2**index.size:
+    if not isinstance(length, sympy.Basic) and 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 {length} != 2**{index.size}"

classiq/model_expansions/capturing/captured_vars.py

@@ -11,7 +11,10 @@ from classiq.interface.exceptions import (
     ClassiqInternalExpansionError,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.classical_type import ClassicalType
+from classiq.interface.generator.functions.classical_type import (
+    CLASSICAL_ATTRIBUTES_TYPES,
+    ClassicalType,
+)
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
@@ -21,6 +24,7 @@ from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
 from classiq.interface.model.handle_binding import (
+    FieldHandleBinding,
     HandleBinding,
     HandlesList,
     NestedHandleBinding,
@@ -172,6 +176,27 @@ class _CapturedClassicalVar(_Captured):
         )
 
 
+@dataclass(frozen=True)
+class _CapturedQuantumTypeAttribute(_Captured):
+    handle: FieldHandleBinding
+    classical_type: ClassicalType
+    defining_function: "FunctionClosure"
+
+    @property
+    def mangled_name(self) -> str:
+        return mangle_captured_var_name(
+            self.handle.identifier,
+            self.defining_function.name,
+            self.defining_function.depth,
+        )
+
+    @property
+    def parameter_declaration(self) -> ClassicalParameterDeclaration:
+        return ClassicalParameterDeclaration(
+            name=self.mangled_name, classical_type=self.classical_type
+        )
+
+
 HandleState = tuple[str, "FunctionClosure", bool]
 
 
@@ -180,6 +205,9 @@ class CapturedVars:
     _captured_handles: list[_CapturedHandle] = field(default_factory=list)
     _handle_states: list[HandleState] = field(default_factory=list)
     _captured_classical_vars: list[_CapturedClassicalVar] = field(default_factory=list)
+    _captured_quantum_type_attributes: list[_CapturedQuantumTypeAttribute] = field(
+        default_factory=list
+    )
 
     def capture_handle(
         self,
@@ -410,11 +438,38 @@ class CapturedVars:
                 return
         self._captured_classical_vars.append(captured_classical_var)
 
+    def capture_quantum_type_attribute(
+        self,
+        handle: FieldHandleBinding,
+        defining_function: "FunctionClosure",
+    ) -> None:
+        self._capture_quantum_type_attribute(
+            _CapturedQuantumTypeAttribute(
+                handle=handle,
+                classical_type=CLASSICAL_ATTRIBUTES_TYPES[handle.field],
+                defining_function=defining_function,
+                is_propagated=False,
+            )
+        )
+
+    def _capture_quantum_type_attribute(
+        self, captured_qta: _CapturedQuantumTypeAttribute
+    ) -> None:
+        for existing_captured_qta in self._captured_quantum_type_attributes:
+            if existing_captured_qta.handle == captured_qta.handle and _same_closure(
+                existing_captured_qta.defining_function,
+                captured_qta.defining_function,
+            ):
+                return
+        self._captured_quantum_type_attributes.append(captured_qta)
+
     def update(self, other_captured_vars: "CapturedVars") -> None:
         for captured_handle in other_captured_vars._captured_handles:
             self._capture_handle(captured_handle)
         for captured_classical_var in other_captured_vars._captured_classical_vars:
             self._capture_classical_var(captured_classical_var)
+        for captured_qta in other_captured_vars._captured_quantum_type_attributes:
+            self._capture_quantum_type_attribute(captured_qta)
 
     def negate(self) -> "CapturedVars":
         return CapturedVars(
@@ -422,7 +477,10 @@ class CapturedVars:
                 captured_handle.change_direction(captured_handle.direction.negate())
                 for captured_handle in self._captured_handles
             ],
-            _captured_classical_vars=self._captured_classical_vars,
+            _captured_classical_vars=list(self._captured_classical_vars),
+            _captured_quantum_type_attributes=list(
+                self._captured_quantum_type_attributes
+            ),
         )
 
     def filter_vars(self, current_function: "FunctionClosure") -> "CapturedVars":
@@ -441,6 +499,11 @@ class CapturedVars:
                     captured_classical_var.defining_function, current_function
                 )
             ],
+            _captured_quantum_type_attributes=[
+                captured_qta
+                for captured_qta in self._captured_quantum_type_attributes
+                if not _same_closure(captured_qta.defining_function, current_function)
+            ],
         )
 
     def filter_var_decls(
@@ -451,12 +514,14 @@ class CapturedVars:
             _captured_handles=[
                 captured_handle
                 for captured_handle in self._captured_handles
-                if (
-                    current_declared_vars is not None
-                    and captured_handle.handle.name not in current_declared_vars
-                )
+                if captured_handle.handle.name not in current_declared_vars
             ],
             _captured_classical_vars=self._captured_classical_vars,
+            _captured_quantum_type_attributes=[
+                captured_qta
+                for captured_qta in self._captured_quantum_type_attributes
+                if (captured_qta.handle.name not in current_declared_vars)
+            ],
         )
 
     def set_propagated(self) -> "CapturedVars":
@@ -469,6 +534,10 @@ class CapturedVars:
                 captured_classical_var.set_propagated()
                 for captured_classical_var in self._captured_classical_vars
             ],
+            _captured_quantum_type_attributes=[
+                captured_qta.set_propagated()
+                for captured_qta in self._captured_quantum_type_attributes
+            ],
         )
 
     def get_captured_parameters(self) -> list[PositionalArg]:
@@ -477,6 +546,10 @@ class CapturedVars:
             captured_classical_var.parameter_declaration
             for captured_classical_var in self._captured_classical_vars
         ]
+        decls += [
+            captured_qta.parameter_declaration
+            for captured_qta in self._captured_quantum_type_attributes
+        ]
         decls += [captured_handle.port for captured_handle in self._captured_handles]
         return decls
 
@@ -494,6 +567,16 @@ class CapturedVars:
             )
             for captured_classical_var in self._captured_classical_vars
         ]
+        args += [
+            Expression(
+                expr=(
+                    str(captured_qta.handle)
+                    if _same_closure(current_function, captured_qta.defining_function)
+                    else captured_qta.mangled_name
+                )
+            )
+            for captured_qta in self._captured_quantum_type_attributes
+        ]
         args += [
             (
                 captured_handle.handle
@@ -504,7 +587,7 @@ class CapturedVars:
         ]
         return args
 
-    def get_immediate_captured_mapping(self) -> SymbolRenaming:
+    def _get_immediate_captured_mapping(self) -> SymbolRenaming:
         return {
             captured_handle.handle: [
                 SymbolPart(
@@ -517,7 +600,7 @@ class CapturedVars:
             if not captured_handle.is_propagated
         }
 
-    def get_propagated_captured_mapping(self) -> SymbolRenaming:
+    def _get_propagated_captured_mapping(self) -> SymbolRenaming:
         return {
             captured_handle.mangled_handle: [
                 SymbolPart(
@@ -529,7 +612,7 @@ class CapturedVars:
             for captured_handle in self._captured_handles
         }
 
-    def get_classical_captured_mapping(self) -> SymbolRenaming:
+    def _get_classical_captured_mapping(self) -> SymbolRenaming:
         return {
             (handle := HandleBinding(name=captured_classical_var.name)): [
                 HandleRenaming(
@@ -541,6 +624,26 @@ class CapturedVars:
             if not captured_classical_var.is_propagated
         }
 
+    def _get_quantum_type_attributes_captured_mapping(self) -> SymbolRenaming:
+        return {
+            (handle := captured_qta.handle): [
+                HandleRenaming(
+                    source_handle=handle,
+                    target_var_name=captured_qta.mangled_name,
+                )
+            ]
+            for captured_qta in self._captured_quantum_type_attributes
+            if not captured_qta.is_propagated
+        }
+
+    def get_captured_mapping(self, is_lambda: bool) -> SymbolRenaming:
+        rewrite_mapping = dict(self._get_propagated_captured_mapping())
+        if is_lambda:
+            rewrite_mapping |= self._get_immediate_captured_mapping()
+            rewrite_mapping |= self._get_classical_captured_mapping()
+            rewrite_mapping |= self._get_quantum_type_attributes_captured_mapping()
+        return rewrite_mapping
+
     def init_var(self, var_name: str, defining_function: "FunctionClosure") -> None:
         self._handle_states.append((var_name, defining_function, False))
 
@@ -606,6 +709,9 @@ class CapturedVars:
             _captured_handles=list(self._captured_handles),
             _handle_states=list(self._handle_states),
             _captured_classical_vars=list(self._captured_classical_vars),
+            _captured_quantum_type_attributes=list(
+                self._captured_quantum_type_attributes
+            ),
         )
 
     def set(
@@ -636,6 +742,14 @@ class CapturedVars:
                 )
             else:
                 self._captured_classical_vars.append(captured_classical_var)
+        self._captured_quantum_type_attributes = []
+        for captured_qta in other._captured_quantum_type_attributes:
+            if _same_closure(captured_qta.defining_function, source_func):
+                self._captured_quantum_type_attributes.append(
+                    captured_qta.change_defining_function(target_func)
+                )
+            else:
+                self._captured_quantum_type_attributes.append(captured_qta)
 
 
 def _same_closure(closure_1: "FunctionClosure", closure_2: "FunctionClosure") -> bool:

classiq/model_expansions/closure.py

@@ -1,5 +1,6 @@
 import dataclasses
 from collections.abc import Sequence
+from copy import deepcopy
 from dataclasses import dataclass, field
 from typing import Any, Optional
 
@@ -104,6 +105,7 @@ class FunctionClosure(Closure):
             scope=self.scope.clone(),
             signature_scope=self.signature_scope.clone(),
             captured_vars=self.captured_vars.clone(),
+            positional_arg_declarations=deepcopy(self.positional_arg_declarations),
         )
 
     def emit(self) -> QuantumCallable:

classiq/model_expansions/evaluators/quantum_type_utils.py

@@ -1,5 +1,3 @@
-from collections.abc import Sequence
-
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
@@ -11,8 +9,6 @@ from classiq.interface.generator.functions.type_name import (
 )
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.inplace_binary_operation import BinaryOperation
-from classiq.interface.model.port_declaration import PortDeclaration
-from classiq.interface.model.quantum_function_declaration import PositionalArg
 from classiq.interface.model.quantum_type import (
     QuantumBit,
     QuantumBitvector,
@@ -147,20 +143,16 @@ def set_length_by_size(
     quantum_array.length = Expression(expr=str(size // element_size))
 
 
-def validate_bind_targets(
-    bind: BindOperation, scope: Scope, allow_symbolic_size: bool
-) -> None:
+def validate_bind_targets(bind: BindOperation, scope: Scope) -> None:
     illegal_qnum_bind_targets = []
     for out_handle in bind.out_handles:
         out_var = scope[out_handle.name].as_type(QuantumSymbol)
         out_var_type = out_var.quantum_type
         if not isinstance(out_var_type, QuantumNumeric):
             continue
-        if (allow_symbolic_size and not out_var_type.is_instantiated) or (
-            not allow_symbolic_size and not out_var_type.has_size_in_bits
-        ):
+        if not out_var_type.has_size_in_bits:
             illegal_qnum_bind_targets.append(str(out_var.handle))
-        elif not allow_symbolic_size and not out_var_type.has_sign:
+        elif not out_var_type.has_sign:
             assert not out_var_type.has_fraction_digits
             illegal_qnum_bind_targets.append(str(out_var.handle))
     if len(illegal_qnum_bind_targets) > 0:
@@ -187,13 +179,6 @@ def get_inplace_op_scalar_as_numeric(
     raise ClassiqInternalExpansionError(f"Unexpected scalar type {var.quantum_type}")
 
 
-def is_signature_monomorphic(params: Sequence[PositionalArg]) -> bool:
-    return all(
-        isinstance(param, PortDeclaration) and param.quantum_type.is_evaluated
-        for param in params
-    )
-
-
 def set_bounds(from_type: QuantumType, to_type: QuantumNumeric) -> None:
     if not isinstance(from_type, QuantumNumeric):
         to_type.reset_bounds()

classiq/model_expansions/function_builder.py

@@ -29,14 +29,7 @@ from classiq.model_expansions.capturing.captured_vars import (
     validate_captured_directions,
     validate_end_state,
 )
-from classiq.model_expansions.closure import (
-    Closure,
-    FunctionClosure,
-    GenerativeFunctionClosure,
-)
-from classiq.model_expansions.evaluators.quantum_type_utils import (
-    is_signature_monomorphic,
-)
+from classiq.model_expansions.closure import Closure, FunctionClosure
 from classiq.model_expansions.scope import Scope
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
 
@@ -225,15 +218,6 @@ class OperationBuilder:
         if name == MAIN_FUNCTION_NAME:
             return name
 
-        if name in self.current_scope:
-            orig_func = self.current_scope[name].value
-            if (
-                isinstance(orig_func, FunctionClosure)
-                and not isinstance(orig_func, GenerativeFunctionClosure)
-                and is_signature_monomorphic(orig_func.positional_arg_declarations)
-            ):
-                return name
-
         for _ in self.current_scope:
             name = self._counted_name_allocator.allocate(
                 f"{name}_{LAMBDA_KEYWORD + '_0_0_' if function_context.is_lambda else ''}{EXPANDED_KEYWORD}"

classiq/model_expansions/quantum_operations/allocate.py

@@ -76,11 +76,15 @@ class AllocateEmitter(Emitter[Allocate]):
         target: QuantumSymbol,
         op_update_dict: dict[str, Expression],
     ) -> None:
-        if not target.quantum_type.is_evaluated:
+        if target.quantum_type.is_evaluated:
+            expr = str(target.quantum_type.size_in_bits)
+        elif self._allow_symbolic_attrs:
+            expr = f"{target.handle}.size"
+        else:
             raise ClassiqValueError(
                 f"Could not infer the size of variable {str(target.handle)!r}"
             )
-        op_update_dict["size"] = Expression(expr=str(target.quantum_type.size_in_bits))
+        op_update_dict["size"] = Expression(expr=expr)
 
     def _handle_with_size(
         self,
@@ -88,7 +92,7 @@ class AllocateEmitter(Emitter[Allocate]):
         size: Expression,
         op_update_dict: dict[str, Expression],
     ) -> None:
-        size_value = self._interpret_size(size)
+        size_value = self._interpret_size(size, str(target.handle))
         op_update_dict["size"] = Expression(expr=str(size_value))
 
         if not isinstance(size_value, sympy.Basic):
@@ -106,12 +110,13 @@ class AllocateEmitter(Emitter[Allocate]):
         fraction_digits: Expression,
         op_update_dict: dict[str, Expression],
     ) -> None:
+        var_name = str(target.handle)
         if not isinstance(target.quantum_type, QuantumNumeric):
             raise ClassiqValueError(
-                f"Non-numeric variable {str(target.handle)!r} cannot be allocated with numeric attributes"
+                f"Non-numeric variable {var_name!r} cannot be allocated with numeric attributes"
             )
 
-        size_value = self._interpret_size(size)
+        size_value = self._interpret_size(size, var_name)
         op_update_dict["size"] = Expression(expr=str(size_value))
         is_signed_value = self._interpret_is_signed(is_signed)
         op_update_dict["is_signed"] = Expression(expr=str(is_signed_value))
@@ -130,12 +135,18 @@ class AllocateEmitter(Emitter[Allocate]):
                     fraction_digits=op_update_dict["fraction_digits"],
                 ),
                 target.quantum_type,
-                str(target.handle),
+                var_name,
             )
 
-    def _interpret_size(self, size: Expression) -> Union[int, float, sympy.Basic]:
+    def _interpret_size(
+        self, size: Expression, var_name: str
+    ) -> Union[int, float, sympy.Basic]:
         size_value = self._interpreter.evaluate(size).value
         if not self._allow_symbolic_attrs and not isinstance(size_value, (int, float)):
+            if size.expr == f"{var_name}.size":
+                raise ClassiqValueError(
+                    f"Could not infer the size of variable {var_name!r}"
+                )
             raise ClassiqValueError(
                 f"The number of allocated qubits must be an integer. Got "
                 f"{str(size_value)!r}"

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -78,7 +78,11 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         expr = self._evaluate_expression(op.expression)
         if len(self._get_classical_vars_in_expression(expr)):
             return None
+
         symbols = self._get_symbols_in_expression(expr)
+        if any(not symbol.quantum_type.is_instantiated for symbol in symbols):
+            return None
+
         expr_str = rename_variables(
             expr.expr,
             {str(symbol.handle): symbol.handle.identifier for symbol in symbols}

classiq/model_expansions/quantum_operations/bind.py

@@ -31,7 +31,8 @@ class BindEmitter(Emitter[BindOperation]):
 
     def emit(self, bind: BindOperation, /) -> bool:
         inputs, outputs = self._get_inputs_outputs(bind)
-        validate_bind_targets(bind, self._current_scope, self._allow_symbolic_size)
+        if not self._allow_symbolic_size:
+            validate_bind_targets(bind, self._current_scope)
         self._process_var_sizes(bind, inputs, outputs)
 
         for symbol in chain(inputs, outputs):