classiq 0.72.1__py3-none-any.whl → 0.73.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.72.1'
+SEMVER_VERSION = '0.73.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/generator/generated_circuit_data.py

@@ -1,6 +1,7 @@
 import logging
 import re
 from typing import Literal, Optional, Union
+from uuid import UUID
 
 import pydantic
 from pydantic import ConfigDict, Field
@@ -16,10 +17,11 @@ from classiq.interface.generator.register_role import RegisterRole
 from classiq.interface.generator.synthesis_metadata.synthesis_execution_data import (
     ExecutionData,
 )
-from classiq.interface.model.quantum_expressions.quantum_expression import (
-    QuantumExpressionOperation,
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperationKind,
 )
 from classiq.interface.model.statement_block import (
+    ArithmeticOperation,
     ConcreteQuantumStatement,
     QuantumFunctionCall,
     StatementBlock,
@@ -141,11 +143,33 @@ class StatementType(StrEnum):
     CONTROL = "control"
     POWER = "power"
     INVERT = "invert"
-    WITHIN_APPLY = "within_apply"
-    ASSIGNMENT = "assignment"
+    WITHIN_APPLY = "within apply"
+    ASSIGN = "assign"
+    ASSIGN_AMPLITUDE = "assign amplitude"
+    PHASE = "phase"
+    INPLACE_XOR = "inplace xor"
+    INPLACE_ADD = "inplace add"
     REPEAT = "repeat"
 
 
+# Mapping between statement kind (or sub-kind) and statement type (visualization name)
+# Keys (statement kind) are taken from the `kind` field of the statement models,
+# which cannot be used directly because they're instance fields of `Literal` type.
+STATEMENTS_NAME: dict[str, StatementType] = {
+    "Control": StatementType.CONTROL,
+    "Power": StatementType.POWER,
+    "Invert": StatementType.INVERT,
+    "WithinApply": StatementType.WITHIN_APPLY,
+    ArithmeticOperationKind.Assignment.value: StatementType.ASSIGN,
+    "InplaceBinaryOperation": StatementType.ASSIGN,
+    "AmplitudeLoadingOperation": StatementType.ASSIGN_AMPLITUDE,
+    "PhaseOperation": StatementType.PHASE,
+    ArithmeticOperationKind.InplaceXor.value: StatementType.INPLACE_XOR,
+    ArithmeticOperationKind.InplaceAdd.value: StatementType.INPLACE_ADD,
+    "Repeat": StatementType.REPEAT,
+}
+
+
 class FunctionDebugInfoInterface(pydantic.BaseModel):
     generated_function: Optional[GeneratedFunction] = Field(default=None)
     children: list["FunctionDebugInfoInterface"]
@@ -154,6 +178,8 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
     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)
@@ -181,14 +207,23 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
         # Temp fix for currently "supported" statements (same as for level_ property)
         if generated_name in {StatementType.CONTROL, StatementType.POWER}:
             return generated_name
-        if self.first_back_ref and isinstance(self.first_back_ref, QuantumFunctionCall):
-            name = generate_original_function_name(self.first_back_ref.func_name)
+
+        back_ref = self.first_back_ref
+        if back_ref is None:
+            return generated_name
+
+        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}"
-        return generated_name
+
+        statement_kind: str = back_ref.kind
+        if isinstance(back_ref, ArithmeticOperation):
+            statement_kind = back_ref.operation_kind.value
+        return STATEMENTS_NAME[statement_kind]
 
     @property
     def first_back_ref(self) -> Optional[ConcreteQuantumStatement]:
@@ -209,10 +244,6 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
             return self.level
         if isinstance(back_ref, QuantumFunctionCall):
             return OperationLevel.QMOD_FUNCTION_CALL
-        # Temp "fix" for assignment statements until we have a way to fully
-        # distinguish them and to properly display them
-        if isinstance(back_ref, QuantumExpressionOperation):
-            return OperationLevel.ENGINE_FUNCTION_CALL
         return OperationLevel.QMOD_STATEMENT
 
     @property

classiq/interface/model/quantum_function_declaration.py

@@ -158,6 +158,7 @@ class AnonQuantumOperandDeclaration(AnonQuantumFunctionDeclaration):
         description="Indicate whether the operand expects an unnamed list of lambdas",
         default=False,
     )
+    _is_generative: bool = pydantic.PrivateAttr(default=False)
 
     @pydantic.model_validator(mode="before")
     @classmethod
@@ -170,7 +171,10 @@ class AnonQuantumOperandDeclaration(AnonQuantumFunctionDeclaration):
         new_instance_data = self.__dict__.copy()
         new_instance_data["name"] = new_name
         new_instance_data["kind"] = "QuantumOperandDeclaration"
-        return QuantumOperandDeclaration(**new_instance_data)
+        new_decl = QuantumOperandDeclaration(**new_instance_data)
+        if self._is_generative:
+            new_decl.set_generative()
+        return new_decl
 
     @property
     def element_declaration(self) -> Self:
@@ -178,6 +182,14 @@ class AnonQuantumOperandDeclaration(AnonQuantumFunctionDeclaration):
             raise ClassiqInternalError
         return self.model_copy(update={"is_list": False})
 
+    def set_generative(self) -> Self:
+        self._is_generative = True
+        return self
+
+    @property
+    def is_generative(self) -> bool:
+        return self._is_generative
+
 
 AnonQuantumFunctionDeclaration.model_rebuild()
 

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -15,6 +15,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_proxy import (
+    ClassicalProxy,
+)
 from classiq.interface.generator.expressions.proxies.quantum.qmod_qscalar_proxy import (
     QmodQNumProxy,
 )
@@ -159,7 +162,7 @@ def struct_literal(struct_type_symbol: Symbol, **kwargs: Any) -> QmodStructInsta
 
 def get_field(
     proxy: Union[
-        QmodSizedProxy, QmodStructInstance, QmodQStructProxy, list, AnyClassicalValue
+        QmodSizedProxy, QmodStructInstance, list, ClassicalProxy, AnyClassicalValue
     ],
     field: str,
 ) -> ExpressionValue:
@@ -179,6 +182,12 @@ def get_field(
                 f"Available attributes: len"
             )
         return len(proxy)
+    if not isinstance(
+        proxy, (QmodSizedProxy, QmodStructInstance, ClassicalProxy, AnyClassicalValue)
+    ):
+        raise ClassiqExpansionError(
+            f"Object {str(proxy)!r} has not attribute {field!r}"
+        )
     if field not in proxy.fields:
         if isinstance(proxy, (QmodStructInstance, QmodQStructProxy)):
             property_name = "field"

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
+from typing import TYPE_CHECKING, Callable
 
 from typing_extensions import Self
 
@@ -40,6 +40,7 @@ from classiq.model_expansions.transformers.model_renamer import (
     SymbolRenaming,
 )
 from classiq.model_expansions.transformers.var_splitter import SymbolPart
+from classiq.model_expansions.utils.text_utils import are, readable_list, s, they
 
 if TYPE_CHECKING:
     from classiq.model_expansions.closure import FunctionClosure
@@ -617,7 +618,9 @@ def _same_closure(closure_1: "FunctionClosure", closure_2: "FunctionClosure") ->
 
 
 def validate_args_are_not_propagated(
-    args: Sequence[ArgValue], captured_vars: Sequence[ArgValue]
+    args: Sequence[ArgValue],
+    captured_vars: Sequence[ArgValue],
+    error_message: Callable[[list[str]], str],
 ) -> None:
     if not captured_vars:
         return
@@ -629,17 +632,16 @@ def validate_args_are_not_propagated(
     arg_handles = {
         demangle_handle(arg) for arg in args if isinstance(arg, HandleBinding)
     }
-    if any(
-        arg_handle.overlaps(captured_handle)
+    violating_handles = [
+        f"{str(arg_handle)!r}"
         for arg_handle in arg_handles
-        for captured_handle in captured_handles
-    ):
-        captured_handles_str = {str(handle) for handle in captured_handles}
-        arg_handles_str = {str(handle) for handle in arg_handles}
-        vars_msg = f"Explicitly passed variables: {arg_handles_str}, captured variables: {captured_handles_str}"
+        if any(
+            arg_handle.overlaps(captured_handle) for captured_handle in captured_handles
+        )
+    ]
+    if len(violating_handles) > 0:
         raise ClassiqExpansionError(
-            f"Cannot capture variables that are explicitly passed as arguments. "
-            f"{vars_msg}"
+            f"Quantum cloning violation: {error_message(violating_handles)}"
         )
 
 
@@ -647,12 +649,12 @@ def validate_captured_directions(
     captured_vars: CapturedVars, report_outin: bool = True
 ) -> None:
     captured_inputs = [
-        captured_handle.handle.name
+        f"{captured_handle.handle.name!r}"
         for captured_handle in captured_vars._captured_handles
         if captured_handle.direction == PortDirection.Input
     ]
     captured_outputs = [
-        captured_handle.handle.name
+        f"{captured_handle.handle.name!r}"
         for captured_handle in captured_vars._captured_handles
         if captured_handle.direction
         in (
@@ -663,11 +665,15 @@ def validate_captured_directions(
     ]
     if len(captured_inputs) > 0:
         raise ClassiqExpansionError(
-            f"Captured quantum variables {captured_inputs!r} cannot be used as inputs"
+            f"Variable{s(captured_inputs)} {readable_list(captured_inputs)} "
+            f"{are(captured_inputs)} defined in an outer block, so "
+            f"{they(captured_inputs)} cannot be freed here"
         )
     if len(captured_outputs) > 0:
         raise ClassiqExpansionError(
-            f"Captured quantum variables {captured_outputs!r} cannot be used as outputs"
+            f"Variable{s(captured_outputs)} {readable_list(captured_outputs)} "
+            f"{are(captured_outputs)} defined in an outer block, so "
+            f"{they(captured_outputs)} cannot be initialized here"
         )
 
 

classiq/model_expansions/generative_functions.py

@@ -16,6 +16,7 @@ from classiq.interface.generator.expressions.proxies.classical.utils import (
     get_proxy_type,
 )
 from classiq.interface.generator.functions.type_name import Struct
+from classiq.interface.helpers.datastructures import get_sdk_compatible_python_object
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
@@ -34,13 +35,12 @@ from classiq.model_expansions.scope import Evaluated, QuantumSymbol
 from classiq.qmod.generative import generative_mode_context, set_frontend_interpreter
 from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.qmod_parameter import CParamStruct, create_param
-from classiq.qmod.qmod_variable import QNum, _create_qvar_for_qtype
+from classiq.qmod.qmod_variable import _create_qvar_for_qtype
 from classiq.qmod.quantum_expandable import (
     QTerminalCallable,
 )
 from classiq.qmod.quantum_function import QFunc
 from classiq.qmod.semantics.annotation.call_annotation import resolve_function_calls
-from classiq.qmod.symbolic_expr import SymbolicExpr
 
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreters.generative_interpreter import (
@@ -65,26 +65,6 @@ def _unwrap_traceback_frame(e: Exception) -> Exception:
     return e.with_traceback(back_tb)
 
 
-class LenList(list):
-    @property
-    def len(self) -> int:
-        return len(self)
-
-    def __getitem__(self, item: Any) -> Any:
-        if isinstance(item, QNum):
-            return SymbolicExpr(f"{self}[{item}]", True)
-        try:
-            return super().__getitem__(item)
-        except (IndexError, TypeError) as e:
-            raise _unwrap_traceback_frame(e) from None
-
-    @classmethod
-    def wrap(cls, obj: Any) -> Any:
-        if not isinstance(obj, list):
-            return obj
-        return LenList([cls.wrap(item) for item in obj])
-
-
 def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated) -> Any:
     if isinstance(param, PortDeclaration):
         quantum_symbol = evaluated.as_type(QuantumSymbol)
@@ -92,28 +72,13 @@ def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated)
             quantum_symbol.quantum_type, quantum_symbol.handle
         )
     if isinstance(param, QuantumOperandDeclaration):
-        if param.is_list:
-            func_list: list[FunctionClosure] = evaluated.as_type(list)
-            return LenList(
-                [
-                    QTerminalCallable(
-                        QuantumOperandDeclaration(
-                            name=param.name,
-                            positional_arg_declarations=param.positional_arg_declarations,
-                        ),
-                        index_=idx,
-                    )
-                    for idx in range(len(func_list))
-                ]
-            )
-        else:
-            func = evaluated.as_type(FunctionClosure)
-            return QTerminalCallable(
-                QuantumFunctionDeclaration(
-                    name=param.name if func.is_lambda else func.name,
-                    positional_arg_declarations=func.positional_arg_declarations,
-                ),
-            )
+        if not param.is_list or not param.is_generative:
+            return QTerminalCallable(param)
+        inner_decl = param.model_copy(update={"is_list": False})
+        func_list: list[FunctionClosure] = evaluated.as_type(list)
+        return [
+            QTerminalCallable(inner_decl, index_=idx) for idx in range(len(func_list))
+        ]
     classical_value = evaluated.value
     if isinstance(classical_value, QmodStructInstance):
         return CParamStruct(
@@ -126,7 +91,7 @@ def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated)
             str(classical_value.handle), get_proxy_type(classical_value), QMODULE
         )
 
-    return LenList.wrap(classical_value)
+    return get_sdk_compatible_python_object(classical_value)
 
 
 class _InterpreterExpandable(QFunc):
@@ -161,15 +126,27 @@ class _InterpreterExpandable(QFunc):
             self._interpreter.emit_statement(stmt)
 
     def _get_function_declarations(self) -> Mapping[str, QuantumFunctionDeclaration]:
-        return {
-            name: QuantumFunctionDeclaration(
-                name=name,
-                positional_arg_declarations=evaluated.value.positional_arg_declarations,
-            )
-            for name, evaluated in self._interpreter._builder.current_scope.items()
-            if isinstance(evaluated, Evaluated)
-            and isinstance(evaluated.value, FunctionClosure)
-        } | nameables_to_dict(self._interpreter._get_function_declarations())
+        scope_func_decls: dict[str, QuantumFunctionDeclaration] = {}
+        for name, evaluated in self._interpreter._builder.current_scope.items():
+            value = evaluated.value
+            if isinstance(value, FunctionClosure):
+                scope_func_decls[name] = QuantumFunctionDeclaration(
+                    name=name,
+                    positional_arg_declarations=value.positional_arg_declarations,
+                )
+            elif (
+                isinstance(value, list)
+                and len(value) > 0
+                and isinstance(value[0], FunctionClosure)
+            ):
+                scope_func_decls[name] = QuantumFunctionDeclaration(
+                    name=name,
+                    positional_arg_declarations=value[0].positional_arg_declarations,
+                )
+        return (
+            nameables_to_dict(self._interpreter._get_function_declarations())
+            | scope_func_decls
+        )
 
 
 def emit_generative_statements(

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -62,6 +62,7 @@ from classiq.model_expansions.quantum_operations.emitter import (
 )
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.model_expansions.transformers.var_splitter import VarSplitter
+from classiq.model_expansions.utils.text_utils import are, readable_list, s
 from classiq.qmod.builtins.functions import free
 from classiq.qmod.semantics.validation.signature_validation import (
     validate_function_signature,
@@ -176,7 +177,11 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         captured_args = function.captured_vars.filter_vars(function).get_captured_args(
             self._builder.current_function
         )
-        validate_args_are_not_propagated(new_positional_args, captured_args)
+        validate_args_are_not_propagated(
+            new_positional_args,
+            captured_args,
+            lambda vars: f"Argument{s(vars)} {readable_list(vars)} {are(vars)} used in adjacent lambda functions",
+        )
         new_positional_args.extend(captured_args)
         new_call = QuantumFunctionCall(
             function=new_declaration.name,

classiq/model_expansions/utils/text_utils.py

@@ -0,0 +1,16 @@
+def s(items: list) -> str:
+    return "" if len(items) == 1 else "s"
+
+
+def are(items: list) -> str:
+    return "is" if len(items) == 1 else "are"
+
+
+def they(items: list) -> str:
+    return "it" if len(items) == 1 else "they"
+
+
+def readable_list(items: list) -> str:
+    if len(items) == 1:
+        return str(items[0])
+    return f"{', '.join(items[:-1])} and {items[-1]}"

classiq/qmod/declaration_inferrer.py

@@ -102,8 +102,10 @@ def _extract_operand_decl(
     name: Optional[str], py_type: Any, qmodule: Optional[ModelStateContainer]
 ) -> AnonQuantumOperandDeclaration:
     is_list = (get_origin(py_type) or py_type) is QCallableList
+    is_generative = False
     if get_origin(py_type) is list:
         is_list = True
+        is_generative = True
         py_type = version_portable_get_args(py_type)[0]
     type_args = version_portable_get_args(py_type)
     if len(type_args) > 0 and isinstance(type_args[0], list):  # Callable support
@@ -116,6 +118,8 @@ def _extract_operand_decl(
         ),
         is_list=is_list,
     )
+    if is_generative:
+        param = param.set_generative()
     if name is not None:
         param = param.rename(name)
     return param

classiq/qmod/quantum_function.py

@@ -42,6 +42,7 @@ class BaseQFunc(QExpandable):
         compilation_metadata: Optional[CompilationMetadata] = None,
     ) -> None:
         super().__init__(py_callable)
+        functools.update_wrapper(self, py_callable)
         self.compilation_metadata = compilation_metadata
 
     @property
@@ -87,7 +88,6 @@ class QFunc(BaseQFunc):
     ) -> None:
         _validate_no_gen_params(py_callable.__annotations__)
         super().__init__(py_callable, compilation_metadata)
-        functools.update_wrapper(self, py_callable)
         self.compilation_metadata: Optional[CompilationMetadata] = None
 
     @property

classiq/qmod/symbolic.py

@@ -9,6 +9,8 @@ from typing import (
     overload,
 )
 
+import numpy as np
+
 from classiq.interface.exceptions import ClassiqValueError
 
 from classiq.qmod import model_state_container
@@ -30,6 +32,15 @@ GoldenRatio = SymbolicExpr("GoldenRatio", False)
 EulerGamma = SymbolicExpr("EulerGamma", False)
 Catalan = SymbolicExpr("Catalan", False)
 
+
+def _unwrap_numpy(x: Any) -> Any:
+    if isinstance(x, np.ndarray):
+        return x.tolist()
+    if isinstance(x, list):
+        return list(map(_unwrap_numpy, x))
+    return x
+
+
 T = TypeVar("T", bound=CParam)
 
 
@@ -45,7 +56,7 @@ def symbolic_function(*args: Any, return_type: Optional[type[T]] = None) -> CPar
     qmodule = (
         model_state_container.QMODULE
     )  # FIXME: https://classiq.atlassian.net/browse/CAD-15126
-    str_args = [str(x) for x in args]
+    str_args = [str(_unwrap_numpy(x)) for x in args]
     expr = f"{sys._getframe(1).f_code.co_name}({','.join(str_args)})"
 
     if return_type is None:
@@ -310,10 +321,12 @@ def _subscript_to_str(index: Any) -> str:
 
 
 def subscript(
-    amplitudes: Union[Sequence[Union[float, CReal, CParamScalar]], CArray[CReal]],
+    array: Union[
+        Sequence[Union[float, CReal, CParamScalar]], CArray[CReal], np.ndarray
+    ],
     index: Any,
 ) -> CParamScalar:
-    return CParamScalar(expr=f"{amplitudes}[{_subscript_to_str(index)}]")
+    return CParamScalar(expr=f"{_unwrap_numpy(array)}[{_subscript_to_str(index)}]")
 
 
 __all__ = [

{classiq-0.72.1.dist-info → classiq-0.73.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: classiq
-Version: 0.72.1
+Version: 0.73.0
 Summary: Classiq's Python SDK for quantum computing
 License: Proprietary
 Keywords: quantum computing,quantum circuits,quantum algorithms,QAD,QDL

{classiq-0.72.1.dist-info → classiq-0.73.0.dist-info}/RECORD

@@ -89,7 +89,7 @@ classiq/execution/jobs.py,sha256=h_aki-Q7RDbG7fyMYdc-kTRNgtq1gX9W5LDub_7J2UM,108
 classiq/execution/qnn.py,sha256=WGPvncz5uS2WxSY3-yBWt2LFiCk6Ug8WKWF-Kp-f7TM,2403
 classiq/executor.py,sha256=9mae_QMGZYT8CJ5QlS4XH7063OYrrDUnt8gAFV-OhRc,2773
 classiq/interface/__init__.py,sha256=cg7hD_XVu1_jJ1fgwmT0rMIoZHopNVeB8xtlmMx-E_A,83
-classiq/interface/_version.py,sha256=8XAX6EDgh67mQdHMDByXxmFs76p9nR0zbuNFGU1Wpw4,197
+classiq/interface/_version.py,sha256=Lc9aqZPOiBQdlmuqFuanaz8FdcjwfMpBSvc-WsDGjkM,197
 classiq/interface/analyzer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 classiq/interface/analyzer/analysis_params.py,sha256=dM5rwSks798cxk4FWe4_X5ToRYtgZQh34F1u0XrFkK8,3881
 classiq/interface/analyzer/cytoscape_graph.py,sha256=MpeRBIYS1TfwYwiFpgTO51IE0KoxhY510pmEM3S0rbw,2361
@@ -254,7 +254,7 @@ classiq/interface/generator/functions/port_declaration.py,sha256=ESJE_19jOg_zS1r
 classiq/interface/generator/functions/qmod_python_interface.py,sha256=x8GA4Cr6YyfC6prGXv0A0I9G9GSnLHNito2nfN1GZDI,93
 classiq/interface/generator/functions/type_name.py,sha256=2HiPejk-WZJy8PkWyYXcpuhGgecVZCUf9mpPWFuYty8,4443
 classiq/interface/generator/functions/type_qualifier.py,sha256=PGiNm_3bczA3TB7ulSemry8zXDB5s4HUIuxdFaVdU_Y,145
-classiq/interface/generator/generated_circuit_data.py,sha256=zy9ZtrEia7SANn7OxygmJj7pyyupxW1e1jQcls5Kd-o,12659
+classiq/interface/generator/generated_circuit_data.py,sha256=S3V2KwGeEG-JaQW0ySUxEDKXEgidfHbeh9WuXZrJFFU,13792
 classiq/interface/generator/grover_diffuser.py,sha256=c52p2_hpjBO0qUDsqFMQ_xffBIDPJlrfz3kIy2Mh2Gk,3750
 classiq/interface/generator/grover_operator.py,sha256=_VzBJ3qO0O0MJzsHf8LF7_ooXnsz1p_I5rjQQFf1Ptg,4119
 classiq/interface/generator/hadamard_transform.py,sha256=NI4oZBpDCGfaw2OTb5SL3iSGI_nDtyUgElTCO4pEKnk,673
@@ -377,7 +377,7 @@ classiq/interface/model/quantum_expressions/amplitude_loading_operation.py,sha25
 classiq/interface/model/quantum_expressions/arithmetic_operation.py,sha256=kqABvyr-niat293lHqBmPhV0Ks3WUgHJ3mevmyD1zD8,2732
 classiq/interface/model/quantum_expressions/quantum_expression.py,sha256=hSWdSJmsEYaZZ62dWI8ueIl_-lqn7FBnwadsqozzZOI,2228
 classiq/interface/model/quantum_function_call.py,sha256=fKDQwYBg8v_WvDsl9QDAA-RBVsW4GOn-zOnpqlhamPg,7384
-classiq/interface/model/quantum_function_declaration.py,sha256=skRip0yD4xvi6yTp4bnHQO0fCgihBk8IVG9DKlUSbC8,8333
+classiq/interface/model/quantum_function_declaration.py,sha256=Er0RfxfpcVO5-ufMkBqSFxKz0BHtu7zCMKnTWOwU_ZM,8675
 classiq/interface/model/quantum_lambda_function.py,sha256=cATqykbArV6c9qmSNtqRgDQjjvCfRvYeC3-S5gJW-wg,1930
 classiq/interface/model/quantum_statement.py,sha256=XthtcTISbdRIv4NW-fckV4jB-dkvYotAZnphMIiK-Ww,3359
 classiq/interface/model/quantum_type.py,sha256=KcwykkbjctiQsMc7XaM3EugKYNE2wVmyPYcclH8K3Lc,10311
@@ -397,9 +397,9 @@ classiq/interface/server/global_versions.py,sha256=EyUtBCoGHjgS4jybiHI8wOZq3WOqv
 classiq/interface/server/routes.py,sha256=9UKBb5c_DWzqM1QBzU1v2I_W0Y__6NnYfjqRFa1FI3g,3400
 classiq/interface/source_reference.py,sha256=a-4Vdc511ux-0lDPDTRGAzouRWWtu4A3MPAfiZe_YPE,1764
 classiq/model_expansions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-classiq/model_expansions/atomic_expression_functions_defs.py,sha256=1j8-b7zpZa1bc7Dgw7VT1fdjCfM4DNNPN1bWIZL2L_A,9504
+classiq/model_expansions/atomic_expression_functions_defs.py,sha256=68iOZfdN_WHPbrdChoMgdElokBqp97mLscMNwmUE82U,9841
 classiq/model_expansions/capturing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-classiq/model_expansions/capturing/captured_vars.py,sha256=SMpnxmYPHMbTG6PtaKUVA0XF_qz6k7NkNxvovTBhzII,26047
+classiq/model_expansions/capturing/captured_vars.py,sha256=KWgLGqt3aE_8Z7EjWsT1huNzSDYW3sBPt0Un902iiZM,26268
 classiq/model_expansions/capturing/mangling_utils.py,sha256=wfCsjP0pScZv9YP6JXq3oVhkS-lCFyUoZ9IROBHS3Ek,1858
 classiq/model_expansions/closure.py,sha256=vCNdYyn_pzoyNGIs4w-ZEm_Vj9925mfu64TDnTdHkys,4975
 classiq/model_expansions/debug_flag.py,sha256=JWzl9FFq2CLcvTg_sh-K8Dp_xXvewsTuFKhPjTCrsrs,107
@@ -414,7 +414,7 @@ classiq/model_expansions/evaluators/quantum_type_utils.py,sha256=s2kqPenO3qaJsiV
 classiq/model_expansions/evaluators/type_type_match.py,sha256=3akZR86TAFKUyM5c5knCPSlraI3LQeWZXxXMTtmu0BI,3220
 classiq/model_expansions/expression_evaluator.py,sha256=Yn_bzK-qtO99XPC3GgbRyn3bMGHy1WoqxYovVjUEOgk,4780
 classiq/model_expansions/function_builder.py,sha256=oVmXhyEu6wr8Ru8LSxIqxwn9gdDoQ26SAPlNnYWCGMI,8697
-classiq/model_expansions/generative_functions.py,sha256=7c0PPp0ydVk77qcMyZQxEa7nY5fUKk2168YftHq1lbA,7268
+classiq/model_expansions/generative_functions.py,sha256=pBOE9gBXDK8CDRwJdTHFOJo0nvBiCMYqUmWyrvYebJY,6714
 classiq/model_expansions/interpreters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 classiq/model_expansions/interpreters/base_interpreter.py,sha256=tvs7Q0LEfzZEUOhcn0gcYXf8obeGbFgyDO7BeN-OxUs,11411
 classiq/model_expansions/interpreters/frontend_generative_interpreter.py,sha256=db1BKh-MDWqLTK8WCXpbNYxxQM4mjqWIhwFtDil7Vd0,3768
@@ -427,7 +427,7 @@ classiq/model_expansions/quantum_operations/arithmetic/explicit_boolean_expressi
 classiq/model_expansions/quantum_operations/assignment_result_processor.py,sha256=OtiqKU6-KxrMBNigSyX4jqohUPzg9qOFa2I-d0DZDK0,2671
 classiq/model_expansions/quantum_operations/bind.py,sha256=KCX_J94-m3taogRGQN7d9sphJyM0XTYaGW_ssBlwIe4,4557
 classiq/model_expansions/quantum_operations/block_evaluator.py,sha256=bESmqOLibwosu4KUh7UdAluwX3ICwO2hbLB7l4x2GYo,3083
-classiq/model_expansions/quantum_operations/call_emitter.py,sha256=KflJEJEupyL77Xqb_eKaXg82GNNbpFY4zSy4Vassl5w,14616
+classiq/model_expansions/quantum_operations/call_emitter.py,sha256=ZCWbQ8mRyzazzv2orCdX0DwuLX9jtQHM4GiEUMWw93A,14842
 classiq/model_expansions/quantum_operations/composite_emitter.py,sha256=B09YGldhWcqdNiyhNzQQU-85mJ_9cRrtNgruDvuyEUE,824
 classiq/model_expansions/quantum_operations/declarative_call_emitter.py,sha256=BlcjV0AG05qpKyWFD2-GJQKqTDWcFfRl7y1z3yIpllc,3209
 classiq/model_expansions/quantum_operations/emitter.py,sha256=jArt-eMikrGbR9fOzY9mP1Vc11Zmkn1UkGcHQWy5sIQ,9700
@@ -450,6 +450,7 @@ classiq/model_expansions/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5
 classiq/model_expansions/utils/counted_name_allocator.py,sha256=9LPLBm-4ZrpC_0r1rbogyF11FnLaGCUyzwWpcBJoSmA,297
 classiq/model_expansions/utils/handles_collector.py,sha256=4RfPsiKjVZkTq2tuS-nvo5OG5gGT_HEALf52SuzJ4Dg,1164
 classiq/model_expansions/utils/sympy_utils.py,sha256=nfmAj2r5NawLlANA5M2IkN3PmQoxNAYYPdaxz79uoEE,682
+classiq/model_expansions/utils/text_utils.py,sha256=rVYVPHLmnmEhsDXwn-90AEaznDyuYRf1kBhD0TMHuls,373
 classiq/model_expansions/visitors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 classiq/model_expansions/visitors/boolean_expression_transformers.py,sha256=a8ITXY48uROZFd9MF8tXdXs14Uxh8XbBpuvRXvRehjY,8067
 classiq/model_expansions/visitors/variable_references.py,sha256=HBgzONJujH8hbtRoqBkT8kBGgE2wDErtfAF_BJXcZC8,5299
@@ -495,7 +496,7 @@ classiq/qmod/cfunc.py,sha256=e3zWNEloBBPy-wJaGI1K5cdNFbd3oq0o4TUY2YDr6ks,1087
 classiq/qmod/classical_function.py,sha256=iHm6T719PUZQPwuNSkouaMA8J9yHrrHUpP-2AQjsA5g,1088
 classiq/qmod/cparam.py,sha256=WqWG_XLYU4SVYDHHXsZNFu0QcE4dfaEM-0C_Q1OOFs0,2007
 classiq/qmod/create_model_function.py,sha256=JhPFmI-_K4Yv-RFcKwWLLhFMpcs35K651ItojXwHolk,2245
-classiq/qmod/declaration_inferrer.py,sha256=8i1EYV6z3b2CJyGd9FOYErixkn807QZWRHzTiG1QqWg,7633
+classiq/qmod/declaration_inferrer.py,sha256=mcqUrrMfolphtNeCn7B0uT4TVAYdx481v6jebmmiRcc,7749
 classiq/qmod/expression_query.py,sha256=24gsE5hJ1o9ZuqPILH7aaoOzKRQY2RZtvIK35xuubGA,1629
 classiq/qmod/generative.py,sha256=MSy-LUsmxteVm3sQSTSWPiYgAskBfYcRHm5EJCYBVZo,1255
 classiq/qmod/model_state_container.py,sha256=yTaowwd468oEntRQAOAhFFgM3cznR9c6ijqrm6U1SBg,1349
@@ -512,7 +513,7 @@ classiq/qmod/qmod_parameter.py,sha256=3WYO11-F8dmbZKqTokmKxzehLdb-aEPYwyiDcAFbbQ
 classiq/qmod/qmod_variable.py,sha256=_Wbg7FyrpBYSLnySJhHt96hWkH0EOwDaHoQJhq1x2ow,24806
 classiq/qmod/quantum_callable.py,sha256=RifbkZEmZ4COOHfluPD2jfd-qYSda2ytW173diR3tI4,2501
 classiq/qmod/quantum_expandable.py,sha256=3GjFdIP7rDv5SMG9scE3_niu04tWELS6u7it2zpRZUg,17640
-classiq/qmod/quantum_function.py,sha256=wQX-9klXdhPGqCFmkHI1wZGsrnt81iTmhw09XhO44_E,12819
+classiq/qmod/quantum_function.py,sha256=a43xlDi3Lb1qVl4xTVXcJfVgPuwDIzAcN-UwpmxzI_c,12819
 classiq/qmod/semantics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 classiq/qmod/semantics/annotation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 classiq/qmod/semantics/annotation/call_annotation.py,sha256=I94YDffDP-PDx3-r8XRFtg7D8B07OyuwnWOGwJVOOOA,3804
@@ -529,13 +530,13 @@ classiq/qmod/semantics/validation/model_validation.py,sha256=BMeleBpQ7WkEi2LNh4j
 classiq/qmod/semantics/validation/signature_validation.py,sha256=WZerCfEwgbCPmXD34iHhXGVATMhJ86sg-dfdOHFZNGg,922
 classiq/qmod/semantics/validation/type_hints.py,sha256=xXhneZhzxXYq40LvZPc4jqNabQGxItKraN91-GWkCDU,1354
 classiq/qmod/semantics/validation/types_validation.py,sha256=uVyW1WlDvUQU7emzHT75QTS0huIlFZr9DgUXLQ7s7vQ,4856
-classiq/qmod/symbolic.py,sha256=eAj-Mkcg5f3JZycKxXivs2yug3Qu-lgy--nJZEjFC5E,7962
+classiq/qmod/symbolic.py,sha256=z5aMUf66pSobTozJif6STWDRJ4YlZv1bxHubbJqecAQ,8209
 classiq/qmod/symbolic_expr.py,sha256=LJoa9c6puMvUu4d5oU0SNzc7VXzSFBUNLf19ADzktLs,6133
 classiq/qmod/symbolic_type.py,sha256=ded7bVfWmHFw8MoyivVDJsG5vZZVRQontOZYb1kCrTQ,162
 classiq/qmod/type_attribute_remover.py,sha256=NZmTXAsngWqthXjE8n-n6yE72fiWTFM12-TXXJ1kJ-Q,1242
 classiq/qmod/utilities.py,sha256=XoB9JU6Vn4p8ZirrUUaP-UpOInm3jwuuYjB6R_V3XLo,5467
 classiq/qmod/write_qmod.py,sha256=Q3TWQU9p_Uy42STmX5GA_4Ts2TTOgYjt7I8LTRxTbb0,2047
 classiq/synthesis.py,sha256=_1W-_shxXEmlhNFKuYz3npiv6P3pWonVn55B0qKRYSo,9052
-classiq-0.72.1.dist-info/METADATA,sha256=VmURBhrvVC2AHAI-8rWyyXjI8Myy5rUipVrLkF2wJUE,3338
-classiq-0.72.1.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-classiq-0.72.1.dist-info/RECORD,,
+classiq-0.73.0.dist-info/METADATA,sha256=3oGZ8EY-94dU4TXW1ZYTssEdTew52vp91GEB1YMLoTo,3338
+classiq-0.73.0.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+classiq-0.73.0.dist-info/RECORD,,