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

classiq/_internals/client.py

@@ -75,25 +75,23 @@ def _get_user_agent_header() -> Headers:
     python_version = (
         f"python({_get_python_execution_environment()})/{platform.python_version()}"
     )
-
-    sdk_env_value = os.getenv("SDK_ENV", "Default")
     os_platform = f"{os.name}/{platform.platform()}"
     frontend_version = f"{_FRONTEND_VARIANT}/{_VERSION}"
     interface_version = f"{_INTERFACE_VARIANT}/{_VERSION}"
-    sdk_env = f"{_SDK_ENV}/{sdk_env_value}"
+
     return {
         "User-Agent": _USERAGENT_SEPARATOR.join(
-            (
-                python_version,
-                os_platform,
-                frontend_version,
-                interface_version,
-                sdk_env,
-            )
+            (python_version, os_platform, frontend_version, interface_version)
         )
     }
 
 
+@functools.lru_cache
+def _get_sdk_env_header() -> Headers:
+    sdk_env_value = os.getenv("SDK_ENV", "Default")
+    return {_SDK_ENV: sdk_env_value}
+
+
 Ret = TypeVar("Ret")
 P = ParamSpec("P")
 
@@ -327,6 +325,7 @@ class Client:
         if self._session_id is not None:
             headers[self._SESSION_HEADER] = self._session_id
         headers.update(_get_user_agent_header())
+        headers.update(_get_sdk_env_header())
         return headers
 
     async def update_expired_access_token(self) -> None:

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

classiq/interface/ast_node.py

@@ -1,4 +1,4 @@
-from typing import Optional, TypeVar
+from typing import Any, Optional, TypeVar
 from uuid import UUID
 
 import pydantic
@@ -23,7 +23,10 @@ class ASTNode(HashablePydanticBaseModel):
 def reset_lists(
     ast_node: ASTNodeType, statement_block_fields: list[str]
 ) -> ASTNodeType:
-    return ast_node.model_copy(update={field: [] for field in statement_block_fields})
+    update: dict[str, Any] = {field: [] for field in statement_block_fields}
+    if hasattr(ast_node, "uuid"):
+        update["uuid"] = ast_node.uuid
+    return ast_node.model_copy(update=update)
 
 
 class HashableASTNode(ASTNode, HashablePydanticBaseModel):

classiq/interface/compression_utils.py

@@ -0,0 +1,31 @@
+import base64
+from collections.abc import Sequence
+from typing import Union
+
+import zstandard as zstd
+from pydantic import BaseModel
+from pydantic_core import from_json, to_json
+
+
+def compress_pydantic(obj: Union[BaseModel, Sequence[BaseModel]]) -> bytes:
+    json_data = to_json(obj)
+    compressed_data = _compress(json_data, level=22)  # max compression level
+    return compressed_data
+
+
+def decompress(compressed_data: bytes) -> Union[dict, list[dict]]:
+    decompressed_data = _decompress(compressed_data)
+    return from_json(decompressed_data)
+
+
+def _compress(data: bytes, level: int) -> bytes:
+    compressor = zstd.ZstdCompressor(level=level)
+    compressed_data = compressor.compress(data)
+    b64_compressed_data = base64.b64encode(compressed_data)
+    return b64_compressed_data
+
+
+def _decompress(data: bytes) -> bytes:
+    compressed_data = base64.b64decode(data)
+    decompressor = zstd.ZstdDecompressor()
+    return decompressor.decompress(compressed_data)

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

@@ -8,6 +8,7 @@ from pydantic import model_validator
 from pydantic_core.core_schema import ValidationInfo
 from typing_extensions import TypeAlias
 
+from classiq.interface.compression_utils import decompress
 from classiq.interface.exceptions import (
     ClassiqMissingOutputFormatError,
     ClassiqStateInitializationError,
@@ -72,6 +73,7 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
     debug_info: Optional[list[FunctionDebugInfoInterface]] = pydantic.Field(
         default=None
     )
+    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)
 
@@ -198,3 +200,15 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
             if self.transpiled_circuit and self._can_use_transpiled_code
             else self
         )
+
+    def get_debug_info(self) -> Optional[list[FunctionDebugInfoInterface]]:
+        # Support legacy uncompressed debug info
+        if self.debug_info is not None:
+            return self.debug_info
+        if self.compressed_debug_info is None:
+            return None
+        decompressed_debug_info_dict_list = decompress(self.compressed_debug_info)
+        return [
+            FunctionDebugInfoInterface.model_validate(debug_info_dict)
+            for debug_info_dict in decompressed_debug_info_dict_list
+        ]

classiq/interface/ide/visual_model.py

@@ -1,4 +1,5 @@
 from collections import Counter
+from functools import cached_property
 from typing import Any, Optional
 
 import pydantic
@@ -58,11 +59,11 @@ class OperationLinks(pydantic.BaseModel):
     inputs: list[OperationLink]
     outputs: list[OperationLink]
 
-    @property
+    @cached_property
     def input_width(self) -> int:
         return sum(len(link.qubits) for link in self.inputs)
 
-    @property
+    @cached_property
     def output_width(self) -> int:
         return sum(len(link.qubits) for link in self.outputs)
 
@@ -122,6 +123,7 @@ class Operation(pydantic.BaseModel):
         default=AtomicGate.UNKNOWN, description="Gate type"
     )
     is_daggered: bool = pydantic.Field(default=False)
+    expanded: bool = pydantic.Field(default=False)
 
 
 class ProgramVisualModel(VersionedModel):

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

@@ -52,6 +52,20 @@ class QuantumLambdaFunction(ASTNode):
     def set_op_decl(self, fd: AnonQuantumOperandDeclaration) -> None:
         self._func_decl = fd
 
+    @property
+    def named_func_decl(self) -> AnonQuantumOperandDeclaration:
+        named_params = [
+            param.rename(rename)
+            for param, rename in zip(
+                self.func_decl.positional_arg_declarations,
+                self.pos_rename_params,
+                strict=False,  # strict=False enables lambda keyword args
+            )
+        ]
+        return self.func_decl.model_copy(
+            update={"positional_arg_declarations": named_params}
+        )
+
 
 class OperandIdentifier(ASTNode):
     name: str

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
@@ -115,6 +116,16 @@ class _CapturedHandle(_Captured):
             self.defining_function.depth,
         )
 
+    @property
+    def mangled_handle(self) -> HandleBinding:
+        return self.handle.rename(
+            mangle_captured_var_name(
+                self.handle.name,
+                self.defining_function.name,
+                self.defining_function.depth,
+            )
+        )
+
     @property
     def port(self) -> PortDeclaration:
         return PortDeclaration(
@@ -484,15 +495,14 @@ class CapturedVars:
             (
                 captured_handle.handle
                 if _same_closure(current_function, captured_handle.defining_function)
-                else HandleBinding(name=captured_handle.mangled_name)
+                else captured_handle.mangled_handle
             )
             for captured_handle in self._captured_handles
         ]
         return args
 
-    def get_captured_mapping(self) -> SymbolRenaming:
-        mapping: SymbolRenaming
-        mapping = {
+    def get_immediate_captured_mapping(self) -> SymbolRenaming:
+        return {
             captured_handle.handle: [
                 SymbolPart(
                     source_handle=captured_handle.handle,
@@ -503,7 +513,21 @@ class CapturedVars:
             for captured_handle in self._captured_handles
             if not captured_handle.is_propagated
         }
-        mapping |= {
+
+    def get_propagated_captured_mapping(self) -> SymbolRenaming:
+        return {
+            captured_handle.mangled_handle: [
+                SymbolPart(
+                    source_handle=captured_handle.mangled_handle,
+                    target_var_name=captured_handle.mangled_name,
+                    target_var_type=captured_handle.quantum_type,
+                )
+            ]
+            for captured_handle in self._captured_handles
+        }
+
+    def get_classical_captured_mapping(self) -> SymbolRenaming:
+        return {
             (handle := HandleBinding(name=captured_classical_var.name)): [
                 HandleRenaming(
                     source_handle=handle,
@@ -513,7 +537,6 @@ class CapturedVars:
             for captured_classical_var in self._captured_classical_vars
             if not captured_classical_var.is_propagated
         }
-        return mapping
 
     def init_var(self, var_name: str, defining_function: "FunctionClosure") -> None:
         self._handle_states.append((var_name, defining_function, False))
@@ -617,7 +640,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 +654,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 +671,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 +687,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/evaluators/type_type_match.py

@@ -85,6 +85,7 @@ def _check_classical_type_match(
 ) -> None:
     if (
         not isinstance(op_param, AnonClassicalParameterDeclaration)
-        or decl_param.classical_type != op_param.classical_type
+        or decl_param.classical_type.set_generative()
+        != op_param.classical_type.set_generative()
     ):
         raise ClassiqExpansionError(error_message)

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/interpreters/generative_interpreter.py

@@ -95,15 +95,11 @@ class GenerativeInterpreter(BaseInterpreter):
         )
 
     def evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
-        renamed_params = [
-            param.rename(function.pos_rename_params[idx])
-            for idx, param in enumerate(function.func_decl.positional_arg_declarations)
-        ]
         func_decl = NamedParamsQuantumFunctionDeclaration(
             name=self._counted_name_allocator.allocate(
                 function.func_decl.name or "<lambda>"
             ),
-            positional_arg_declarations=renamed_params,
+            positional_arg_declarations=function.named_func_decl.positional_arg_declarations,
         )
 
         closure_class: type[FunctionClosure]

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,
@@ -258,11 +263,11 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             chain.from_iterable((func_def.positional_arg_declarations, captured_ports))
         )
 
-        if not function_context.is_lambda:
-            return func_def
-        func_def.body = self.rewrite(
-            func_def.body, captured_vars.get_captured_mapping()
-        )
+        rewrite_mapping = dict(captured_vars.get_propagated_captured_mapping())
+        if function_context.is_lambda:
+            rewrite_mapping |= captured_vars.get_immediate_captured_mapping()
+            rewrite_mapping |= captured_vars.get_classical_captured_mapping()
+        func_def.body = self.rewrite(func_def.body, rewrite_mapping)
 
         return func_def
 

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/open_library/functions/__init__.py

@@ -98,6 +98,7 @@ __all__ = [
     "grover_search",
     "hadamard_transform",
     "inplace_c_modular_multiply",
+    "inplace_prepare_complex_amplitudes",
     "inplace_prepare_int",
     "linear_pauli_rotations",
     "modular_exp",
@@ -105,6 +106,7 @@ __all__ = [
     "multiswap",
     "phase_oracle",
     "prepare_bell_state",
+    "prepare_complex_amplitudes",
     "prepare_exponential_state",
     "prepare_ghz_state",
     "prepare_int",

classiq/open_library/functions/amplitude_amplification.py

@@ -1,3 +1,5 @@
+import numpy as np
+
 from classiq.open_library.functions.grover import grover_operator
 from classiq.qmod.builtins.functions.standard_gates import RY
 from classiq.qmod.builtins.operations import (
@@ -11,7 +13,7 @@ from classiq.qmod.cparam import CInt, CReal
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import QArray, QBit
 from classiq.qmod.quantum_callable import QCallable
-from classiq.qmod.symbolic import acos, asin, ceiling, pi, sin
+from classiq.qmod.symbolic import acos, asin, ceiling, sin
 
 
 @qfunc
@@ -67,8 +69,8 @@ def exact_amplitude_amplification(
         packed_vars: The variable that holds the state to be amplified. Assumed to be in the zero state at the beginning of the algorithm.
     """
     aux = QBit()
-    k = ceiling((pi / (4 * asin(amplitude))) - 0.5)
-    theta = pi / (4 * k + 2)
+    k = ceiling((np.pi / (4 * asin(amplitude))) - 0.5)
+    theta = np.pi / (4 * k + 2)
     rot_phase = 2 * acos(sin(theta) / amplitude)
 
     extended_qvars: QArray = QArray()

classiq/open_library/functions/state_preparation.py

@@ -1,12 +1,23 @@
 import warnings
 from typing import Literal
 
+import numpy as np
+import sympy
+
 from classiq.interface.exceptions import ClassiqDeprecationWarning
 
 from classiq.open_library.functions.utility_functions import hadamard_transform
-from classiq.qmod.builtins.functions.standard_gates import CX, IDENTITY, RY, H, X
+from classiq.qmod.builtins.functions import (
+    CX,
+    IDENTITY,
+    RY,
+    RZ,
+    H,
+    X,
+    inplace_prepare_amplitudes,
+)
 from classiq.qmod.builtins.operations import allocate, control, if_, inplace_add, repeat
-from classiq.qmod.cparam import CBool, CInt
+from classiq.qmod.cparam import CArray, CBool, CInt, CReal
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import Output, QArray, QBit, QNum
 from classiq.qmod.symbolic import (
@@ -298,3 +309,85 @@ def prepare_int(
         stacklevel=1,
     )
     out |= value
+
+
+def _control_qubit(i: int) -> int:
+    if _msb(_graycode(i)) < _msb(_graycode(i + 1)):
+        return (_graycode(i) & _graycode(i + 1)).bit_length() - 1
+    return (_graycode(i) ^ _graycode(i + 1)).bit_length() - 1
+
+
+def _graycode(i: int) -> int:
+    return i ^ (i >> 1)
+
+
+def _msb(x: int) -> int:
+    """
+    largest non zero bit
+    """
+    if x == 0:
+        return 0
+    return x.bit_length() - 1
+
+
+def _classical_hadamard_transform(arr: list[float]) -> np.ndarray:
+    return 1 / np.sqrt(len(arr)) * np.array(sympy.fwht(np.array(arr)))
+
+
+@qfunc(generative=True)
+def _load_phases(
+    phases: list[float],
+    target: QArray[QBit, Literal["log(get_field(phases, 'len'), 2)"]],
+) -> None:
+    alphas = -2 * _classical_hadamard_transform(phases) / np.sqrt(len(phases))
+
+    for i in range(1, len(alphas) - 1):
+        gray = _graycode(i)
+        next_gray = _graycode(i + 1)
+        RZ(alphas[gray], target[_msb(gray)])
+        CX(target[_control_qubit(i)], target[_msb(next_gray)])
+
+    RZ(alphas[_graycode(len(phases) - 1)], target[target.len - 1])
+
+
+@qfunc
+def inplace_prepare_complex_amplitudes(
+    magnitudes: CArray[CReal],
+    phases: CArray[CReal],
+    target: QArray[QBit, Literal["log(get_field(magnitudes, 'len'), 2)"]],
+) -> None:
+    """
+
+    [Qmod Classiq-library function]
+
+    Prepares a quantum state with amplitudes and phases for each state according to the given parameters, in polar representation.
+    Expects to act on an initialized zero state $|0\\rangle$.
+
+    Args:
+        magnitudes: Absolute values of the state amplitudes.
+        phases: phases of the state amplitudes. should be of the same size as `amplitudes`.
+        target: The quantum variable to act upon.
+    """
+    inplace_prepare_amplitudes(magnitudes, 0, target)
+    _load_phases(phases, target)
+
+
+@qfunc
+def prepare_complex_amplitudes(
+    magnitudes: CArray[CReal],
+    phases: CArray[CReal],
+    out: Output[QArray[QBit, Literal["log(get_field(magnitudes, 'len'), 2)"]]],
+) -> None:
+    """
+
+    [Qmod Classiq-library function]
+
+    Initializes and prepares a quantum state with amplitudes and phases for each state according to the given parameters, in polar representation.
+
+    Args:
+        magnitudes: Absolute values of the state amplitudes.
+        phases: phases of the state amplitudes. should be of the same size as `amplitudes`.
+        out: The allocated quantum variable. Must be uninitialized.
+    """
+    allocate(out)
+    inplace_prepare_complex_amplitudes(magnitudes, phases, out)

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

@@ -24,13 +24,16 @@ class ModelStateContainer:
     generative_functions: dict[str, "GenerativeQFunc"]
     function_dependencies: dict[str, list[str]]
 
+    def reset(self) -> None:
+        self.enum_decls = {}
+        self.type_decls = {}
+        self.qstruct_decls = {}
+        self.native_defs = {}
+        self.constants = {}
+        self.functions_compilation_metadata = {}
+        self.generative_functions = {}
+        self.function_dependencies = defaultdict(list)
+
 
 QMODULE = ModelStateContainer()
-QMODULE.enum_decls = {}
-QMODULE.type_decls = {}
-QMODULE.qstruct_decls = {}
-QMODULE.native_defs = {}
-QMODULE.constants = {}
-QMODULE.functions_compilation_metadata = {}
-QMODULE.generative_functions = {}
-QMODULE.function_dependencies = defaultdict(list)
+QMODULE.reset()

classiq/qmod/quantum_function.py

@@ -1,7 +1,6 @@
 import ast
 import functools
 from abc import abstractmethod
-from collections import defaultdict
 from dataclasses import is_dataclass
 from enum import EnumMeta
 from inspect import isclass
@@ -42,6 +41,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 +87,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
@@ -120,14 +119,7 @@ class QFunc(BaseQFunc):
         preferences: Optional[Preferences] = None,
         classical_execution_function: Optional[CFunc] = None,
     ) -> Model:
-        self._qmodule.enum_decls = dict()
-        self._qmodule.type_decls = dict()
-        self._qmodule.qstruct_decls = dict()
-        self._qmodule.native_defs = dict()
-        self._qmodule.constants = dict()
-        self._qmodule.functions_compilation_metadata = dict()
-        self._qmodule.generative_functions = dict()
-        self._qmodule.function_dependencies = defaultdict(list)
+        self._qmodule.reset()
         QConstant.set_current_model(self._qmodule)
         self.expand()
         model_extra_settings: list[tuple[str, Any]] = [

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.74.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: classiq
-Version: 0.72.1
+Version: 0.74.0
 Summary: Classiq's Python SDK for quantum computing
 License: Proprietary
 Keywords: quantum computing,quantum circuits,quantum algorithms,QAD,QDL
@@ -53,6 +53,7 @@ Requires-Dist: tabulate (>=0.8.9,<1)
 Requires-Dist: torch ; extra == "qml"
 Requires-Dist: torchvision ; extra == "qml"
 Requires-Dist: tqdm (>=4.67.1,<5.0.0)
+Requires-Dist: zstandard (>=0.23.0,<0.24.0)
 Description-Content-Type: text/markdown
 
 <p align="center">

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

@@ -11,7 +11,7 @@ classiq/_internals/authentication/authentication.py,sha256=58Xv1QtynXwEfBqIV5E3L
 classiq/_internals/authentication/device.py,sha256=dUii1-Z26j0NY4R6J4p0gjYSq5Goj-gwMxXPSnVANuE,4024
 classiq/_internals/authentication/password_manager.py,sha256=nhJyr8IGrsq3oaGtD0UXZ_rCN4GPI-4LrTYHc1R--sQ,4464
 classiq/_internals/authentication/token_manager.py,sha256=XStkqCPUQEqc3uj6tt_XzfUIcUlyT-94tBZ8tpQIy_s,5280
-classiq/_internals/client.py,sha256=m6ZHmpEJdGhKQRqDdxjjW4qzwvdf86_7lSHrjpiG9O8,12638
+classiq/_internals/client.py,sha256=gHnkpKedytRAXaRasU2CkICttbQd2IsT1tAPPGd8oTU,12634
 classiq/_internals/config.py,sha256=-UKKvPp_61sxXY-URqU1feLqlfh9ww4wCDH4yl14EiA,3534
 classiq/_internals/help.py,sha256=9gl64Y8nKW-f-8pYt7lMozOP6uERcIIf8dotgn_WKA0,460
 classiq/_internals/host_checker.py,sha256=D0rgnoZrHo62rYS32yCuYZSyMrMChZG5ITsJxwj0R5g,3969
@@ -89,14 +89,14 @@ 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=BI-nVueUF-_bvqJGZ-QZZhNBUCxdF-1lsoJ82-C2X4M,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
 classiq/interface/analyzer/result.py,sha256=CJhZ7Q_VUCyKS1ivtyD9l9534efjEUY6C6Wwrb3kXak,5872
 classiq/interface/applications/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 classiq/interface/applications/qsvm.py,sha256=4dHVSZH--sv58SvxmpDHPh9JDr4qQUZbbGCeaEv6b1I,3408
-classiq/interface/ast_node.py,sha256=tHMBLw-iTAZq724XTDkqg9hxh_8zKC73oKXmawP8Wd0,827
+classiq/interface/ast_node.py,sha256=-X3lke3c2Wm0fGDupj0g4cGfuRmLv4hA4EjLsJ1dHqE,941
 classiq/interface/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 classiq/interface/backend/backend_preferences.py,sha256=apW0rA9nQSrU8NUa9piFPfoKiMQWQJnUILewn73DVqc,21539
 classiq/interface/backend/ionq/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -134,6 +134,7 @@ classiq/interface/combinatorial_optimization/optimization_problem.py,sha256=iiC1
 classiq/interface/combinatorial_optimization/result.py,sha256=kDGShpwzhp8KOibngo3SFnfZGBjT0ClmS86a3Yrlgj8,198
 classiq/interface/combinatorial_optimization/sense.py,sha256=P8_kJRf3aUKbCkIqOP3tOc81Vpz9yW4Z74RGaYbd9TA,262
 classiq/interface/combinatorial_optimization/solver_types.py,sha256=kcLt80fQucq_DWmJXmmVljwCGV4gtDnqOMlJdemhPQc,135
+classiq/interface/compression_utils.py,sha256=rX4sD4_8C-liWqBICuE6VaT38yjUK_FneSA5GUmPF2A,973
 classiq/interface/debug_info/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 classiq/interface/debug_info/back_ref_util.py,sha256=plWBiBMfFIY6aYAR3NVYComsY394ysLVdk_yFy1qcC4,791
 classiq/interface/debug_info/debug_info.py,sha256=XZ3zNzJb1whiHKLpKZpDITXEeV3tbhwEAhHa5cSzABE,4263
@@ -254,7 +255,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
@@ -295,7 +296,7 @@ classiq/interface/generator/qft.py,sha256=SDLcPWYxshDfPl-tAfhpRFb30NpPRRFpje5Jrr
 classiq/interface/generator/qpe.py,sha256=C6CddpuD196TUVpUEvvlA9uaRLmFlTkwrHheaWbGojY,6526
 classiq/interface/generator/qsvm.py,sha256=Ry2iTC2NIoh0u9BsuwVaO-ICUBbRIF7Of9scJG4sGFs,3056
 classiq/interface/generator/quantum_function_call.py,sha256=BlqclMwh_Qj6_yXUTIBM23eLdQ_X3x_KTQ4WWwBN4JY,24123
-classiq/interface/generator/quantum_program.py,sha256=gozSsrXYGWu3JOG97hKlyK0f-vIAr3ZPxpRfubOX1zc,7476
+classiq/interface/generator/quantum_program.py,sha256=k4NU1up8UCofrPNZMTYurCAJfiVwBJ1oH0-e3ER8vGA,8131
 classiq/interface/generator/randomized_benchmarking.py,sha256=D6KI_1fMF5oBydaal2WLmTSit6xSMtz0yDAIZMMO89Q,635
 classiq/interface/generator/range_types.py,sha256=X6CtSyimlpISz9QNbCdqqQkRg1pOGHEQCXy4aEeSwA4,2044
 classiq/interface/generator/register_role.py,sha256=moerPIO9gQUuG5pe43TemmScSVjTK7_gi-qbrhIgLOA,1147
@@ -352,7 +353,7 @@ classiq/interface/helpers/validation_helpers.py,sha256=Jt0xs5EZeEQZOBEZPRmKctHmA
 classiq/interface/helpers/versioned_model.py,sha256=kBgEghNdSidohb0-p_EjRFZLs7LAmLZ_uKIHZFSZ8cQ,159
 classiq/interface/ide/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 classiq/interface/ide/ide_data.py,sha256=TtFsBttR7L34DeRx4NaswpdyMqEyAuguEWSvGXfZtZs,2504
-classiq/interface/ide/visual_model.py,sha256=0eqoW44c4cROZnehQ_5Euh_BFvzzWBCUSDbFjYaCYJE,3171
+classiq/interface/ide/visual_model.py,sha256=nnauOxOCJrWmc_W0Qtn7RoXlXYY3dPxr_ZPNCtHDaaE,3274
 classiq/interface/interface_version.py,sha256=w1gZSbPPwcEizEoNhHnkmxXxmkHXCNsHFARLKnhrUbk,24
 classiq/interface/jobs.py,sha256=i8hrBR2qtptCbxNI-PVYZedH_EDehOe2i09JbJUlD1g,2339
 classiq/interface/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -377,8 +378,8 @@ 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_lambda_function.py,sha256=cATqykbArV6c9qmSNtqRgDQjjvCfRvYeC3-S5gJW-wg,1930
+classiq/interface/model/quantum_function_declaration.py,sha256=Er0RfxfpcVO5-ufMkBqSFxKz0BHtu7zCMKnTWOwU_ZM,8675
+classiq/interface/model/quantum_lambda_function.py,sha256=Jvw8N_GYSwqlAg5RchBSJ3LwYO2U5ImmELaHpvRTWOg,2420
 classiq/interface/model/quantum_statement.py,sha256=XthtcTISbdRIv4NW-fckV4jB-dkvYotAZnphMIiK-Ww,3359
 classiq/interface/model/quantum_type.py,sha256=KcwykkbjctiQsMc7XaM3EugKYNE2wVmyPYcclH8K3Lc,10311
 classiq/interface/model/quantum_variable_declaration.py,sha256=Vmx-aHnss8E_ghqX_wi4Njp-dEtYK-WwYHtHAwmGZxk,229
@@ -397,9 +398,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=l1niB6GGOayu6PkfY4ImyjkQbRnORp93S60wHRBOpjs,27002
 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
@@ -411,14 +412,14 @@ classiq/model_expansions/evaluators/classical_type_inference.py,sha256=Ex2A8uhiU
 classiq/model_expansions/evaluators/control.py,sha256=rFSP5kuQZfh0OPMuf0OmiDVlX_c0stl2mKX4tnIhAHA,4110
 classiq/model_expansions/evaluators/parameter_types.py,sha256=OjGQspqVkHJfSft7InuwH6SCvB9Pfc6ktNjDCL8pBDY,9261
 classiq/model_expansions/evaluators/quantum_type_utils.py,sha256=s2kqPenO3qaJsiVa1bo5t4cpJ-MZeRqlVvM9TXPtyBI,7729
-classiq/model_expansions/evaluators/type_type_match.py,sha256=3akZR86TAFKUyM5c5knCPSlraI3LQeWZXxXMTtmu0BI,3220
+classiq/model_expansions/evaluators/type_type_match.py,sha256=iNDLigrBiSuAQE0zReJFuvtlYyWjk86Gv7ytz3h0LHI,3262
 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
-classiq/model_expansions/interpreters/generative_interpreter.py,sha256=0cY4wHaOhJIdFrXWWajR1VxdBSCIjaOejmnX2WZ3jf0,12112
+classiq/model_expansions/interpreters/generative_interpreter.py,sha256=HYh782nXN9_0xFTF6PwQsU8m79wbmiwP1aHIWqFvZF8,11967
 classiq/model_expansions/model_tables.py,sha256=dlrOGRS2x4Fd_dzClIcV7V8edmbbQzePv9eqxtJQrpo,620
 classiq/model_expansions/quantum_operations/__init__.py,sha256=iLROXHuWaYKWPYJHUM_6uRNKa9-I7oDPYn1yqYFpYgM,309
 classiq/model_expansions/quantum_operations/allocate.py,sha256=Y00O9rVbXHt_yShLv63UJHO4gju0L-ft4I-xIvSNlFE,3037
@@ -427,7 +428,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=Bt8nVgJxQWZHMFIirHc0V0eZ_7nfmIAyKlUKlGZga-4,15003
 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,12 +451,13 @@ 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
 classiq/open_library/__init__.py,sha256=bmg_qqXCXo85hcU7_QCce-qYGrpAVSFNwTKCClsclrg,114
-classiq/open_library/functions/__init__.py,sha256=8JIijCqjmfFNvGm5PrCD-5MRI7iF78cgRku-GvIoPow,3282
-classiq/open_library/functions/amplitude_amplification.py,sha256=O21jANyhXGQuvmByDdOaFkaReL5BkCUkGMLM0tEFBZ0,4176
+classiq/open_library/functions/__init__.py,sha256=Xf4XbgHLZphUO5Qw6v5kIi3_fW77jidivjmoHDa3qe8,3358
+classiq/open_library/functions/amplitude_amplification.py,sha256=4lmK7-26VhZmWhBmhYCNrA44A8uo2Njycg8lFcVLc_U,4198
 classiq/open_library/functions/amplitude_estimation.py,sha256=iCkca5SQN_HQoJWk1_tLT56fHT72hu5QIt2pxSZQRko,1766
 classiq/open_library/functions/discrete_sine_cosine_transform.py,sha256=mutvfffkrEEFrFJp1bUliJBnOEnkv4rUQ7q1Pka9V8E,4439
 classiq/open_library/functions/grover.py,sha256=yoMnx4jAF0b2hQqwaKMpPgdbqe9ZCsx2u95Yr029q_I,4367
@@ -467,7 +469,7 @@ classiq/open_library/functions/qaoa_penalty.py,sha256=Uz_ZSn7fRwynP5w2eSOEcft2z4
 classiq/open_library/functions/qft_functions.py,sha256=7pdPBq48QvyQkxHrF3rEKTf0J50qUu_2bN17lfSc7I0,1382
 classiq/open_library/functions/qpe.py,sha256=e7MBpOthBn73BdqhWpNGT0lkd6Jw3ZG7tE6n--IM0jc,2140
 classiq/open_library/functions/qsvt.py,sha256=wpLq0P-pmhdTaRQJJWRHwbTZqRnE1M58MfQ2y1C0YUI,14271
-classiq/open_library/functions/state_preparation.py,sha256=mx8EgXGoNsaWgsU56FfTNy_JOq2cVBoH0p8Un8cROXk,10603
+classiq/open_library/functions/state_preparation.py,sha256=g5UHPYNpP8mvRFM61jk_6c1KhWmmzqi9k0AR_GKnNLg,13202
 classiq/open_library/functions/swap_test.py,sha256=hAjiJjZGeJP2qzEkVYmBVlEK44VcNibWZ-KqJwPEcFY,1048
 classiq/open_library/functions/utility_functions.py,sha256=MFxuk49vdjNIqLPxdloigACfXmuxmqrP_oSJbO49Rbc,2541
 classiq/open_library/functions/variational.py,sha256=KYoqPKYRjgUXk_10RvogV0YiCG5kl7GZBHBJeeX82II,1715
@@ -495,10 +497,10 @@ 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
+classiq/qmod/model_state_container.py,sha256=eeE5sCo7dbMI6A_opNo0rGEtB7uSIQfv6szBcbamANI,1435
 classiq/qmod/native/__init__.py,sha256=gm0L3ew0KAy0eSqaMQrvpnKWx85HoA1p9ADaAlyejdA,126
 classiq/qmod/native/expression_to_qmod.py,sha256=a33dDr7BGWl7YhsFjpfAuI9Ys7amJjMo4DImSrD4NZg,7143
 classiq/qmod/native/pretty_printer.py,sha256=hcvv2PJLeZbJfh7jsWA_ZhpA3kpo9E_cWkW6iVJ7jwE,17421
@@ -512,7 +514,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=vXytpoxeeOao08AkLc_yZ1em4xujqFf4dMeASUJBPi0,12422
 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 +531,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.74.0.dist-info/METADATA,sha256=M6xZoSaXkyGLUXsariLsJ16P9l858Zo5ELuwYcYcOnI,3382
+classiq-0.74.0.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+classiq-0.74.0.dist-info/RECORD,,