classiq 0.80.1__py3-none-any.whl → 0.82.0__py3-none-any.whl

classiq/analyzer/show_interactive_hack.py

@@ -27,10 +27,16 @@ def is_classiq_studio() -> bool:
     return bool(os.environ.get("OPENVSCODE"))
 
 
-def get_app_url(data_id: DataID, circuit: QuantumProgram) -> str:
+def get_app_url(
+    data_id: DataID, circuit: QuantumProgram, include_query: bool = True
+) -> str:
     return urljoin(
         client_ide_base_url(),
-        circuit_page_uri(circuit_id=data_id.id, circuit_version=circuit.version),
+        circuit_page_uri(
+            circuit_id=data_id.id,
+            circuit_version=circuit.version,
+            include_query=include_query,
+        ),
     )
 
 
@@ -95,7 +101,7 @@ async def handle_remote_app(circuit: QuantumProgram, display_url: bool = True) -
 
     renderer = get_visualization_renderer()
     if display_url:
-        app_url = get_app_url(circuit_dataid, circuit)
+        app_url = get_app_url(circuit_dataid, circuit, include_query=False)
         print(f"Quantum program link: {app_url}")  # noqa: T201
     await renderer(circuit_dataid, circuit)
 
@@ -111,7 +117,7 @@ async def _show_interactive(self: QuantumProgram, display_url: bool = True) -> N
             Whether to print the url
 
     Links:
-        [Visualization tool](https://docs.classiq.io/latest/reference-manual/analyzer/quantum-program-visualization-tool/)
+        [Visualization tool](https://docs.classiq.io/latest/user-guide/analysis/quantum-program-visualization-tool/)
     """
     await handle_remote_app(self, display_url)
 

classiq/analyzer/url_utils.py

@@ -24,8 +24,9 @@ def circuit_page_search_params(circuit_version: str) -> str:
     )
 
 
-def circuit_page_uri(circuit_id: str, circuit_version: str) -> str:
+def circuit_page_uri(circuit_id: str, circuit_version: str, include_query: bool) -> str:
     url = urljoin(f"{routes.ANALYZER_CIRCUIT_PAGE}/", circuit_id)
-    query_string = circuit_page_search_params(circuit_version)
-    url += QUERY_START_MARK + query_string
+    if include_query:
+        query_string = circuit_page_search_params(circuit_version)
+        url += QUERY_START_MARK + query_string
     return url

classiq/applications/qnn/qlayer.py

@@ -273,6 +273,6 @@ class QLayer(nn.Module):
             self._epsilon,
         )
 
-    def _cleanup(self) -> None:
+    def teardown(self) -> None:
         if hasattr(self, "_session"):
             self._session.close()

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

classiq/interface/backend/backend_preferences.py

@@ -30,9 +30,6 @@ class BackendPreferences(BaseModel):
     """
     Preferences for the execution of the quantum program.
 
-    For more details, refer to:
-    [BackendPreferences](https://docs.classiq.io/latest/reference-manual/python-sdk/?h=backend#classiq.Preferences.backend_preferences)
-
     Attributes:
         backend_service_provider (str): Provider company or cloud for the requested backend.
         backend_name (str): Name of the requested backend or target.

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/executor/execution_preferences.py

@@ -29,7 +29,8 @@ class ExecutionPreferences(pydantic.BaseModel):
     Execution preferences for running a quantum program.
 
     For more details, refer to:
-    `ExecutionPreferences example: [ExecutionPreferences](https://docs.classiq.io/latest/reference-manual/executor/?h=execution+pref#execution-preferences)..
+    ExecutionPreferences example: [ExecutionPreferences](https://docs.classiq.io/latest/user-guide/execution/#execution-preferences)..
+
 
     Attributes:
         noise_properties (Optional[NoiseProperties]): Properties defining the noise in the quantum circuit. Defaults to `None`.

classiq/interface/generator/compiler_keywords.py

@@ -1,8 +1,8 @@
 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:
-    return name.split(f"_{EXPANDED_KEYWORD}")[0]
+    return name.split(f"_{LAMBDA_KEYWORD}")[0].split(f"_{EXPANDED_KEYWORD}")[0]

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

@@ -1,4 +1,5 @@
 import uuid
+import warnings
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Optional, Union
@@ -8,6 +9,7 @@ from typing_extensions import TypeAlias
 
 from classiq.interface.compression_utils import decompress
 from classiq.interface.exceptions import (
+    ClassiqDeprecationWarning,
     ClassiqMissingOutputFormatError,
     ClassiqStateInitializationError,
 )
@@ -72,6 +74,8 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
     compressed_debug_info: Optional[bytes] = pydantic.Field(default=None)
     program_id: str = pydantic.Field(default_factory=get_uuid_as_str)
     execution_primitives_input: Optional[PrimitivesInput] = pydantic.Field(default=None)
+    synthesis_warnings: Optional[list[str]] = pydantic.Field(default=None)
+    should_warn: bool = pydantic.Field(default=False)
 
     def __str__(self) -> str:
         return self.model_dump_json(indent=2)
@@ -198,3 +202,12 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
             FunctionDebugInfoInterface.model_validate(debug_info_dict)
             for debug_info_dict in decompressed_debug_info_dict_list
         ]
+
+    def raise_warnings(self) -> None:
+        """
+        Raises all warnings that were collected during synthesis.
+        """
+        if self.synthesis_warnings is None:
+            return
+        for warning in self.synthesis_warnings:
+            warnings.warn(warning, ClassiqDeprecationWarning, stacklevel=2)

classiq/interface/generator/types/compilation_metadata.py

@@ -1,7 +1,19 @@
-from pydantic import BaseModel, Field, NonNegativeInt
+from pydantic import BaseModel, Field, NonNegativeInt, PrivateAttr
 
 
 class CompilationMetadata(BaseModel):
     should_synthesize_separately: bool = Field(default=False)
     occurrences_number: NonNegativeInt = Field(default=1)
-    atomic_qualifiers: list[str] = Field(default_factory=list)
+    _occupation_number: NonNegativeInt = PrivateAttr(default=0)
+    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                                                                                                                                                                                       atomic_qualifiers: list[str] = Field(default_factory=list)
+
+    @property
+    def occupation_number(self) -> NonNegativeInt:
+        return self._occupation_number
+
+    @occupation_number.setter
+    def occupation_number(self, value: NonNegativeInt) -> None:
+        self._occupation_number = value

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()