classiq 0.61.0__py3-none-any.whl → 0.62.0__py3-none-any.whl

classiq/applications/combinatorial_helpers/optimization_model.py

@@ -23,7 +23,10 @@ from classiq.applications.combinatorial_helpers import (
 )
 from classiq.applications.combinatorial_helpers.encoding_mapping import EncodingMapping
 from classiq.applications.combinatorial_helpers.memory import InternalQuantumReg
-from classiq.applications.combinatorial_helpers.pyomo_utils import get_field_name
+from classiq.applications.combinatorial_helpers.pyomo_utils import (
+    get_field_name,
+    is_index_var,
+)
 from classiq.applications.combinatorial_helpers.transformations import (
     encoding,
     ising_converter,
@@ -176,7 +179,11 @@ class OptimizationModel:
             for key, value in penalty_map.pyomo2sympy.items():
                 objective_map.pyomo2sympy[key] = value
         sympy_mapping = {
-            sympy_var: get_field_name(pyomo_var)
+            sympy_var: (
+                get_field_name(pyomo_var)
+                if not is_index_var(pyomo_var)
+                else (get_field_name(pyomo_var.parent_component()), pyomo_var.index())
+            )
             for pyomo_var, sympy_var in objective_map.pyomo2sympy.items()
         }
         self.objective_not_encoded_sympy = sympy_mapping, objective_expr

classiq/applications/combinatorial_helpers/pyomo_utils.py

@@ -1,5 +1,6 @@
 import math
 import re
+from collections import defaultdict
 from enum import Enum
 from typing import Any, Optional, TypeVar, Union
 
@@ -24,7 +25,7 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import Integer
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
 
-from classiq.qmod.qmod_variable import QBit, QNum, QStruct, QVar
+from classiq.qmod.qmod_variable import QArray, QBit, QNum, QStruct, QVar
 from classiq.qmod.symbolic_expr import SymbolicExpr
 
 ListVars = list[_GeneralVarData]
@@ -262,14 +263,51 @@ def pyomo_to_qmod_qstruct(
     struct_name: str, vars: list[_GeneralVarData]
 ) -> type[QStruct]:
     qmod_struct = type(struct_name, (QStruct,), {})
-    var_names = {get_field_name(var): var for var in vars}
-    qmod_struct.__annotations__ = {
-        var_name: _get_qmod_field_type(var_name, var_data)
-        for var_name, var_data in var_names.items()
-    }
+    qmod_struct.__annotations__ = _get_qstruct_fields(vars)
     return qmod_struct
 
 
+def _get_qstruct_fields(vars: list[_GeneralVarData]) -> dict[str, type[QVar]]:
+    array_types = _get_array_types(vars)
+    array_type_sizes = _get_array_sizes(array_types)
+    fields: dict[str, type[QVar]] = {}
+    for var in vars:
+        _add_qmod_field(var, array_type_sizes, fields)
+    return fields
+
+
+def _get_array_types(vars: list[_GeneralVarData]) -> dict[str, set[int]]:
+    array_types: dict[str, set[int]] = defaultdict(set)
+    for var in vars:
+        if is_index_var(var):
+            array_types[var.parent_component().name].add(var.index())
+    return array_types
+
+
+def _get_array_sizes(array_types: dict[str, set[int]]) -> dict[str, int]:
+    return {
+        name: array_size
+        for name, indices in array_types.items()
+        if indices == set(range(array_size := len(indices)))
+    }
+
+
+def _add_qmod_field(
+    var: _GeneralVarData,
+    array_type_sizes: dict[str, int],
+    fields: dict[str, type[QVar]],
+) -> None:
+    parent_name = var.parent_component().name
+    if parent_name not in array_type_sizes:
+        var_name = get_field_name(var)
+        fields[var_name] = _get_qmod_field_type(var_name, var)
+    elif var.index() == 0:
+        fields[parent_name] = QArray[  # type:ignore[misc]
+            _get_qmod_field_type(parent_name, var),
+            array_type_sizes[parent_name],
+        ]
+
+
 def _get_qmod_field_type(var_name: str, var_data: _GeneralVarData) -> type[QVar]:
     if var_data.domain not in SUPPORTED_TYPES:
         raise ClassiqValueError(
@@ -294,11 +332,17 @@ def _get_qmod_field_type(var_name: str, var_data: _GeneralVarData) -> type[QVar]
 
 
 def evaluate_objective(
-    var_mapping: dict, sympy_expr: sympy.Expr, struct_obj: Any
+    var_mapping: dict[Any, Union[str, tuple[str, int]]],
+    sympy_expr: sympy.Expr,
+    struct_obj: Any,
 ) -> Any:
     sympy_assignment = {
-        sympy_var: getattr(struct_obj, field_name)
-        for sympy_var, field_name in var_mapping.items()
+        sympy_var: (
+            getattr(struct_obj, field_accessor)
+            if isinstance(field_accessor, str)
+            else getattr(struct_obj, field_accessor[0])[field_accessor[1]]
+        )
+        for sympy_var, field_accessor in var_mapping.items()
     }
 
     # classical objective evaluation
@@ -315,3 +359,10 @@ def evaluate_objective(
 
 def get_field_name(var: _GeneralVarData) -> str:
     return var.local_name.replace("[", "_").replace("]", "")
+
+
+def is_index_var(var: _GeneralVarData) -> bool:
+    return (
+        isinstance(var.index(), int)
+        and "[" not in var.parent_component().name  # nested arrays not supported
+    )

classiq/applications/combinatorial_optimization/combinatorial_problem.py

@@ -6,11 +6,13 @@ import numpy as np
 import pandas as pd
 import pyomo.core as pyo
 import scipy
+from tqdm import tqdm
 
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.executor.result import ExecutionDetails
 from classiq.interface.model.model import SerializedModel
 
+from classiq import Constraints, Preferences
 from classiq.applications.combinatorial_helpers.combinatorial_problem_utils import (
     pyo_model_to_qmod_problem,
 )
@@ -37,7 +39,7 @@ class CombinatorialProblem:
         num_layers: int,
         penalty_factor: int = 1,
     ):
-        self.problem_vars_, self.cost_func_ = pyo_model_to_qmod_problem(
+        self.problem_vars_, self.cost_func = pyo_model_to_qmod_problem(
             pyo_model, penalty_factor
         )
         self.num_layers_ = num_layers
@@ -45,8 +47,26 @@ class CombinatorialProblem:
         self.qprog_ = None
         self.es_ = None
         self.optimized_params_ = None
+        self.params_trace_: list[np.ndarray] = []
+        self.cost_trace_: list = []
 
-    def get_model(self) -> SerializedModel:
+    @property
+    def cost_trace(self) -> list:
+        return self.cost_trace_
+
+    @property
+    def params_trace(self) -> list[np.ndarray]:
+        return self.params_trace_
+
+    @property
+    def optimized_params(self) -> list:
+        return self.optimized_params_  # type:ignore[return-value]
+
+    def get_model(
+        self,
+        constraints: Optional[Constraints] = None,
+        preferences: Optional[Preferences] = None,
+    ) -> SerializedModel:
         @qfunc
         def main(
             params: CArray[CReal, self.num_layers_ * 2],  # type:ignore[valid-type]
@@ -58,13 +78,15 @@ class CombinatorialProblem:
                 self.num_layers_,
                 lambda i: [  # type:ignore[arg-type]
                     phase(
-                        -self.cost_func_(v), params[i]
+                        -self.cost_func(v), params[i]
                     ),  # type:ignore[func-returns-value]
                     apply_to_all(lambda q: RX(params[self.num_layers_ + i], q), v),
                 ],
             )
 
-        self.model_ = create_model(main)  # type:ignore[assignment]
+        self.model_ = create_model(
+            main, constraints=constraints, preferences=preferences
+        )  # type:ignore[assignment]
         return self.model_  # type:ignore[return-value]
 
     def get_qprog(self) -> SerializedQuantumProgram:
@@ -77,7 +99,6 @@ class CombinatorialProblem:
         self,
         execution_preferences: Optional[ExecutionPreferences] = None,
         maxiter: int = 20,
-        cost_trace: Optional[list[float]] = None,
         quantile: float = 1.0,
     ) -> list[float]:
         if self.qprog_ is None:
@@ -85,40 +106,52 @@ class CombinatorialProblem:
         self.es_ = ExecutionSession(
             self.qprog_, execution_preferences  # type:ignore[assignment,arg-type]
         )
+        self.params_trace_ = []
+        self.cost_trace_ = []
 
         def estimate_cost_wrapper(params: np.ndarray) -> float:
             cost = self.es_.estimate_cost(  # type:ignore[attr-defined]
-                lambda state: self.cost_func_(state["v"]),
+                lambda state: self.cost_func(state["v"]),
                 {"params": params.tolist()},
                 quantile=quantile,
             )
-            if cost_trace is not None:
-                cost_trace.append(cost)
+            self.cost_trace_.append(cost)
+            self.params_trace_.append(params)
             return cost
 
         initial_params = (
             np.concatenate(
                 (
-                    np.linspace(0, 1, self.num_layers_),
-                    np.linspace(1, 0, self.num_layers_),
+                    np.linspace(1 / self.num_layers_, 1, self.num_layers_),
+                    np.linspace(1, 1 / self.num_layers_, self.num_layers_),
                 )
             )
             * math.pi
         )
-        self.optimized_params_ = scipy.optimize.minimize(
-            estimate_cost_wrapper,
-            x0=initial_params,
-            method="COBYLA",
-            options={"maxiter": maxiter},
-        ).x.tolist()
+
+        with tqdm(total=maxiter, desc="Optimization Progress", leave=True) as pbar:
+
+            def _minimze_callback(xk: np.ndarray) -> None:
+                pbar.update(1)  # increment progress bar
+                self.optimized_params_ = xk.tolist()  # save recent optimized value
+
+            self.optimized_params_ = scipy.optimize.minimize(
+                estimate_cost_wrapper,
+                callback=_minimze_callback,
+                x0=initial_params,
+                method="COBYLA",
+                options={"maxiter": maxiter},
+            ).x.tolist()
+
         return self.optimized_params_  # type:ignore[return-value]
 
-    def get_results(self) -> pd.DataFrame:
-        if self.optimized_params_ is None:
-            self.optimize()
+    def sample_uniform(self) -> pd.DataFrame:
+        return self.sample([0] * self.num_layers_ * 2)
+
+    def sample(self, params: list) -> pd.DataFrame:
         assert self.es_ is not None
         res = self.es_.sample(  # type:ignore[unreachable]
-            {"params": self.optimized_params_}
+            {"params": params}
         )
         parsed_result = [
             {
@@ -128,7 +161,7 @@ class CombinatorialProblem:
                     if not re.match(".*_slack_var_.*", key)
                 },
                 "probability": sampled.shots / res.num_shots,
-                "cost": self.cost_func_(sampled.state["v"]),
+                "cost": self.cost_func(sampled.state["v"]),
             }
             for sampled in res.parsed_counts
         ]

classiq/execution/jobs.py

@@ -112,7 +112,15 @@ class ExecutionJob:
         )
         return cls(details)
 
-    from_id = syncify_function(from_id_async)
+    # `syncify_function` doesn't work well for class methods, so I wrote `from_id`
+    # explicitly
+    @classmethod
+    def from_id(
+        cls,
+        id: str,
+        _http_client: Optional[httpx.AsyncClient] = None,
+    ) -> "ExecutionJob":
+        return syncify_function(cls.from_id_async)(id, _http_client=_http_client)
 
     @property
     def _job_id(self) -> JobID:

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

classiq/interface/backend/backend_preferences.py

@@ -161,6 +161,20 @@ class ClassiqBackendPreferences(BackendPreferences):
     def is_nvidia_backend(self) -> bool:
         return self.backend_name in list(ClassiqNvidiaBackendNames)
 
+    # CAD-25390
+    @pydantic.field_validator("backend_name")
+    @classmethod
+    def _validate_nvidia_name_backwards_compatibility(cls, backend_name: str) -> str:
+        if backend_name == "nvidia_state_vector_simulator":
+            warnings.warn(
+                "The name 'nvidia_state_vector_simulator' is deprecated and "
+                "will be removed soon, no earlier than January 12th 2025. "
+                "Please use ClassiqNvidiaBackendNames.SIMULATOR instead",
+                ClassiqDeprecationWarning,
+                stacklevel=2,
+            )
+        return backend_name
+
 
 class AwsBackendPreferences(BackendPreferences):
     """
@@ -196,13 +210,17 @@ class AwsBackendPreferences(BackendPreferences):
     backend_service_provider: ProviderTypeVendor.AMAZON_BRAKET = pydantic.Field(
         default=ProviderVendor.AMAZON_BRAKET
     )
-    aws_role_arn: pydantic_backend.PydanticAwsRoleArn = pydantic.Field(
+    aws_role_arn: Optional[pydantic_backend.PydanticAwsRoleArn] = pydantic.Field(
         description="ARN of the role to be assumed for execution on your Braket account."
     )
-    s3_bucket_name: str = pydantic.Field(description="S3 Bucket Name")
-    s3_folder: pydantic_backend.PydanticS3BucketKey = pydantic.Field(
+    s3_bucket_name: Optional[str] = pydantic.Field(description="S3 Bucket Name")
+    s3_folder: Optional[pydantic_backend.PydanticS3BucketKey] = pydantic.Field(
         description="S3 Folder Path Within The S3 Bucket"
     )
+    run_through_classiq: bool = pydantic.Field(
+        default=False,
+        description="Run through Classiq's credentials while using user's allocated budget.",
+    )
 
     @pydantic.field_validator("s3_bucket_name", mode="before")
     @classmethod

classiq/interface/backend/quantum_backend_providers.py

@@ -170,7 +170,8 @@ class ClassiqNvidiaBackendNames(StrEnum):
     Classiq's Nvidia simulator backend names.
     """
 
-    SIMULATOR = "nvidia_state_vector_simulator"
+    SIMULATOR = "nvidia_simulator"
+    SIMULATOR_STATEVECTOR = "nvidia_simulator_statevector"
 
 
 class IntelBackendNames(StrEnum):
@@ -186,6 +187,7 @@ class GoogleNvidiaBackendNames(StrEnum):
     """
 
     CUQUANTUM = "cuquantum"
+    CUQUANTUM_STATEVECTOR = "cuquantum_statevector"
 
 
 class AliceBobBackendNames(StrEnum):

classiq/interface/generator/copy.py

@@ -0,0 +1,47 @@
+from typing import Optional
+
+import pydantic
+
+from classiq.interface.generator.arith import argument_utils
+from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
+from classiq.interface.generator.function_params import FunctionParams
+
+
+class Copy(FunctionParams):
+    source: argument_utils.RegisterOrConst
+    target: RegisterArithmeticInfo
+    output_size: Optional[pydantic.PositiveInt] = pydantic.Field(default=None)
+
+    @property
+    def source_size(self) -> int:
+        return argument_utils.size(self.source)
+
+    @property
+    def source_reg_size(self) -> int:
+        return (
+            self.source.size if isinstance(self.source, RegisterArithmeticInfo) else 0
+        )
+
+    @property
+    def source_fraction_places(self) -> int:
+        return argument_utils.fraction_places(self.source)
+
+    @property
+    def offset(self) -> int:
+        return self.target.fraction_places - self.source_fraction_places
+
+    @property
+    def source_name(self) -> str:
+        return "source"
+
+    @property
+    def target_name(self) -> str:
+        return "target"
+
+    def _create_ios(self) -> None:
+        self._inputs = {
+            self.target_name: self.target,
+        }
+        if isinstance(self.source, RegisterArithmeticInfo):
+            self._inputs[self.source_name] = self.source
+        self._outputs = {**self._inputs}

classiq/interface/generator/function_param_list_without_self_reference.py

@@ -28,6 +28,7 @@ from classiq.interface.generator.arith.unary_ops import BitwiseInvert, Negation,
 from classiq.interface.generator.commuting_pauli_exponentiation import (
     CommutingPauliExponentiation,
 )
+from classiq.interface.generator.copy import Copy
 from classiq.interface.generator.entangler_params import (
     GridEntangler,
     HypercubeEntangler,
@@ -148,6 +149,7 @@ function_param_library_without_self_reference: FunctionParamLibrary = (
                 PiecewiseLinearAmplitudeLoading,
                 PiecewiseLinearRotationAmplitudeLoading,
                 HadamardTransform,
+                Copy,
             },
             standard_gate_function_param_library.param_list,
             oracle_function_param_library.param_list,

classiq/interface/generator/model/preferences/preferences.py

@@ -156,7 +156,7 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
     )
     synthesize_all_separately: bool = pydantic.Field(
         default=False,
-        description="If true, all functions will be synthesized separately",
+        description="If true, a heuristic is used to determine if a function should be synthesized separately",
     )
     output_format: PydanticConstrainedQuantumFormatList = pydantic.Field(
         default=[QuantumFormat.QASM],

classiq/interface/generator/types/compilation_metadata.py

@@ -1,5 +1,6 @@
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, NonNegativeInt
 
 
 class CompilationMetadata(BaseModel):
     should_synthesize_separately: bool = Field(default=False)
+    occurrences_number: NonNegativeInt = Field(default=1)

classiq/model_expansions/capturing/captured_vars.py

@@ -1,6 +1,5 @@
 import dataclasses
-from collections.abc import Iterator, Sequence
-from contextlib import contextmanager
+from collections.abc import Sequence
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Optional
 
@@ -277,11 +276,8 @@ class CapturedVars:
             if not captured_handle.is_propagated
         }
 
-    @contextmanager
-    def freeze(self) -> Iterator[None]:
-        previous = self._captured_handles
-        yield
-        self._captured_handles = previous
+    def clone(self) -> "CapturedVars":
+        return CapturedVars(_captured_handles=list(self._captured_handles))
 
 
 def _same_closure(closure_1: "FunctionClosure", closure_2: "FunctionClosure") -> bool:
@@ -311,7 +307,9 @@ def validate_args_are_not_propagated(
         )
 
 
-def validate_captured_directions(captured_vars: CapturedVars) -> None:
+def validate_captured_directions(
+    captured_vars: CapturedVars, report_outin: bool = True
+) -> None:
     captured_inputs = [
         captured_handle.handle.name
         for captured_handle in captured_vars._captured_handles
@@ -320,7 +318,12 @@ def validate_captured_directions(captured_vars: CapturedVars) -> None:
     captured_outputs = [
         captured_handle.handle.name
         for captured_handle in captured_vars._captured_handles
-        if captured_handle.direction == PortDirection.Output
+        if captured_handle.direction
+        in (
+            (PortDirection.Output, PortDirection.Outin)
+            if report_outin
+            else (PortDirection.Output,)
+        )
     ]
     if len(captured_inputs) > 0:
         raise ClassiqExpansionError(

classiq/model_expansions/closure.py

@@ -1,8 +1,7 @@
 import dataclasses
 import json
 import uuid
-from collections.abc import Collection, Iterator, Sequence
-from contextlib import contextmanager
+from collections.abc import Collection, Sequence
 from dataclasses import dataclass, field
 from functools import singledispatch
 from symtable import Symbol
@@ -51,11 +50,6 @@ class Closure:
             if isinstance(param, PortDeclaration)
         }
 
-    @contextmanager
-    def freeze(self) -> Iterator[None]:
-        with self.scope.freeze(), self.captured_vars.freeze():
-            yield
-
 
 @dataclass(frozen=True)
 class GenerativeClosure(Closure):
@@ -142,9 +136,12 @@ class FunctionClosure(Closure):
     def set_depth(self, depth: int) -> Self:
         return dataclasses.replace(self, _depth=depth)
 
-    def copy_scope(self) -> Self:  # Remove when scoping is normal (CAD-24980)
+    def clone(self) -> Self:
         return dataclasses.replace(
-            self, scope=Scope(self.scope.data, parent=self.scope.parent)
+            self,
+            scope=self.scope.clone(),
+            signature_scope=self.signature_scope.clone(),
+            captured_vars=self.captured_vars.clone(),
         )
 
 

classiq/model_expansions/function_builder.py

@@ -92,6 +92,10 @@ class OperationBuilder:
     def current_operation(self) -> Closure:
         return self._operations[-1].closure
 
+    @property
+    def current_scope(self) -> Scope:
+        return self.current_operation.scope
+
     @property
     def current_function(self) -> FunctionClosure:
         return self._get_last_function(self._operations)
@@ -137,7 +141,8 @@ class OperationBuilder:
             validate_captured_directions(
                 captured_vars.filter_vars(
                     self.current_function, self.current_block.variable_declarations
-                )
+                ),
+                report_outin=False,
             )
         self.current_operation.captured_vars.update(
             captured_vars.filter_vars(self.current_function)

classiq/model_expansions/generative_functions.py

@@ -116,7 +116,7 @@ class _InterpreterExpandable(QFunc):
                 name=name,
                 positional_arg_declarations=evaluated.value.positional_arg_declarations,
             )
-            for name, evaluated in self._interpreter._current_scope.items()
+            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())

classiq/model_expansions/interpreter.py

@@ -1,6 +1,6 @@
-import copy
-from collections.abc import Iterator, Sequence
-from contextlib import contextmanager, nullcontext
+from collections import defaultdict
+from collections.abc import Sequence
+from contextlib import nullcontext
 from functools import singledispatchmethod
 from typing import Any, Optional, cast
 
@@ -111,8 +111,7 @@ class Interpreter:
     ) -> None:
         self._is_frontend = is_frontend
         self._model = model
-        self._current_scope = Scope()
-        self._top_level_scope = self._current_scope
+        self._top_level_scope = Scope()
         self._builder = OperationBuilder(self._top_level_scope)
         self._expanded_functions: dict[str, NativeFunctionDefinition] = {}
 
@@ -123,33 +122,19 @@ class Interpreter:
         if generative_functions is None:
             generative_functions = []
         self._generative_functions = generative_functions
-        init_top_level_scope(model, generative_functions, self._current_scope)
+        init_top_level_scope(model, generative_functions, self._top_level_scope)
         self._expanded_functions_compilation_metadata: dict[
             str, CompilationMetadata
-        ] = dict()
+        ] = defaultdict(CompilationMetadata)
         self._counted_name_allocator = CountedNameAllocator()
         self._error_manager: ErrorManager = ErrorManager()
 
-    @contextmanager
-    def _scope_guard(self, scope: Scope) -> Iterator[None]:
-        """This manager restores both `scope` and `self._current_scope` to their previous values."""
-        scope_data = copy.copy(scope.data)
-        prev_context_scope_data = copy.copy(self._current_scope.data)
-
-        prev_context_scope = self._current_scope
-        self._current_scope = scope
-        yield
-        prev_context_scope.data = prev_context_scope_data
-        self._current_scope = prev_context_scope
-
-        scope.data = scope_data
-
     def _expand_main_func(self) -> None:
         main_closure = FunctionClosure.create(
             name=self._model.main_func.name,
             positional_arg_declarations=self._model.main_func.positional_arg_declarations,
             body=self._model.main_func.body,
-            scope=Scope(parent=self._current_scope),
+            scope=Scope(parent=self._top_level_scope),
             expr_renamer=self._main_renamer,
             _depth=0,
         )
@@ -198,11 +183,11 @@ class Interpreter:
 
     @evaluate.register
     def evaluate_classical_expression(self, expression: Expression) -> Evaluated:
-        return evaluate_classical_expression(expression, self._current_scope)
+        return evaluate_classical_expression(expression, self._builder.current_scope)
 
     @evaluate.register
     def evaluate_identifier(self, identifier: str) -> Evaluated:
-        return self._current_scope[identifier]
+        return self._builder.current_scope[identifier]
 
     @evaluate.register
     def evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
@@ -233,7 +218,7 @@ class Interpreter:
                 name=func_decl.name,
                 positional_arg_declarations=func_decl.positional_arg_declarations,
                 body=function.body,
-                scope=Scope(parent=self._current_scope),
+                scope=Scope(parent=self._builder.current_scope),
                 is_lambda=True,
                 **extra_args,
             ),
@@ -390,19 +375,16 @@ class Interpreter:
                 pass
             elif isinstance(operation, FunctionClosure) and operation.name == "permute":
                 # special expansion since permute is generative
-                with self._scope_guard(operation.scope):
-                    self._expand_permute()
+                self._expand_permute()
             elif isinstance(operation, GenerativeClosure):
-                with self._scope_guard(operation.scope):
-                    args = [
-                        self.evaluate(param.name)
-                        for param in operation.positional_arg_declarations
-                    ]
-                    emit_generative_statements(self, operation, args)
+                args = [
+                    self.evaluate(param.name)
+                    for param in operation.positional_arg_declarations
+                ]
+                emit_generative_statements(self, operation, args)
             else:
                 for block, block_body in operation.blocks.items():
-                    with self._scope_guard(operation.scope):
-                        self._expand_block(block_body, block)
+                    self._expand_block(block_body, block)
 
         return context
 

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -53,7 +53,7 @@ if TYPE_CHECKING:
 class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSplitter):
     def __init__(self, interpreter: "Interpreter") -> None:
         Emitter.__init__(self, interpreter)
-        VarSplitter.__init__(self, interpreter._current_scope)
+        VarSplitter.__init__(self, interpreter._builder.current_scope)
 
     @staticmethod
     def _should_wrap(body: Sequence[QuantumStatement]) -> bool:
@@ -90,8 +90,8 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         args: list[ArgValue],
         propagated_debug_info: Optional[FunctionDebugInfo] = None,
     ) -> QuantumFunctionCall:
+        function = function.clone()
         function = function.set_depth(self._builder.current_function.depth + 1)
-        function = function.copy_scope()
         evaluated_args = [self._interpreter.evaluate(arg) for arg in args]
         new_declaration = self._prepare_fully_typed_declaration(
             function, evaluated_args
@@ -115,15 +115,20 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
                 self._top_level_scope[function_def.name] = Evaluated(
                     value=function_context.closure.with_new_declaration(function_def)
                 )
+                compilation_metadata = self._functions_compilation_metadata.get(
+                    function.name
+                )
+                if compilation_metadata is not None:
+                    self._expanded_functions_compilation_metadata[function_def.name] = (
+                        compilation_metadata
+                    )
+            else:
+                self._expanded_functions_compilation_metadata[
+                    function_def.name
+                ].occurrences_number += 1
+
             new_declaration = function_def
             new_function_name = function_def.name
-            compilation_metadata = self._functions_compilation_metadata.get(
-                function.name
-            )
-            if compilation_metadata is not None:
-                self._expanded_functions_compilation_metadata[new_function_name] = (
-                    compilation_metadata
-                )
 
         new_positional_args = self._get_new_positional_args(
             evaluated_args, is_atomic, new_positional_arg_decls
@@ -239,13 +244,12 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         different from the call scope. For example, the former uses r,s and the latter
         uses p, q.
         """
-        with self._scope_guard(Scope(parent=self._current_scope)):
-            # The signature scope is passed as a separate argument to avoid contaminating the statement execution scope
-            return NamedParamsQuantumFunctionDeclaration(
-                name=function.name,
-                positional_arg_declarations=evaluate_parameter_types_from_args(
-                    function,
-                    function.signature_scope,
-                    evaluated_args,
-                ),
-            )
+        # The signature scope is passed as a separate argument to avoid contaminating the statement execution scope
+        return NamedParamsQuantumFunctionDeclaration(
+            name=function.name,
+            positional_arg_declarations=evaluate_parameter_types_from_args(
+                function,
+                function.signature_scope,
+                evaluated_args,
+            ),
+        )

classiq/model_expansions/quantum_operations/emitter.py

@@ -49,7 +49,6 @@ class Emitter(Generic[QuantumStatementT]):
     def __init__(self, interpreter: "Interpreter") -> None:
         self._interpreter = interpreter
 
-        self._scope_guard = self._interpreter._scope_guard
         self._machine_precision = self._interpreter._model.preferences.machine_precision
         self._expanded_functions_compilation_metadata = (
             self._interpreter._expanded_functions_compilation_metadata
@@ -71,7 +70,7 @@ class Emitter(Generic[QuantumStatementT]):
 
     @property
     def _current_scope(self) -> Scope:
-        return self._interpreter._current_scope
+        return self._builder.current_scope
 
     @property
     def _top_level_scope(self) -> Scope:
@@ -104,7 +103,7 @@ class Emitter(Generic[QuantumStatementT]):
         )
         gen_closure = GenerativeClosure(
             name=func_decl.name,
-            scope=Scope(parent=self._interpreter._current_scope),
+            scope=Scope(parent=self._interpreter._builder.current_scope),
             blocks={},
             generative_blocks={
                 block_name: GenerativeQFunc(

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -18,7 +18,7 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
     def emit(self, call: QuantumFunctionCall, /) -> None:
         function = self._interpreter.evaluate(call.function).as_type(FunctionClosure)
         args = call.positional_args
-        with ErrorManager().call(function.name), function.freeze():
+        with ErrorManager().call(function.name):
             self._emit_quantum_function_call(
                 function, args, self._debug_info.get(call.uuid)
             )

classiq/model_expansions/quantum_operations/shallow_emitter.py

@@ -11,6 +11,9 @@ from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
     ArithmeticOperationKind,
 )
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumAssignmentOperation,
+)
 from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
 
 from classiq.model_expansions.closure import Closure
@@ -68,12 +71,15 @@ class ShallowEmitter(Emitter[QuantumOperation]):
             ).value.handle
 
         op = op.model_copy(update=expanded_components)
-        if isinstance(op, ArithmeticOperation):
+        if isinstance(op, QuantumAssignmentOperation):
             self._post_process_assignment(op)
         self._builder.emit_statement(op)
 
-    def _post_process_assignment(self, op: ArithmeticOperation) -> None:
-        if op.operation_kind == ArithmeticOperationKind.Assignment:
+    def _post_process_assignment(self, op: QuantumAssignmentOperation) -> None:
+        if (
+            isinstance(op, ArithmeticOperation)
+            and op.operation_kind == ArithmeticOperationKind.Assignment
+        ):
             direction = PortDeclarationDirection.Output
             self._update_result_type(op)
         else:

classiq/model_expansions/scope.py

@@ -2,7 +2,6 @@ import itertools
 import re
 from collections import UserDict
 from collections.abc import Iterator
-from contextlib import contextmanager
 from dataclasses import dataclass
 from functools import singledispatch
 from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
@@ -231,14 +230,5 @@ class Scope(EvaluatedUserDict):
             parent=parent,
         )
 
-    def _copy(self) -> "Scope":
-        return Scope(
-            self.data, parent=None if self._parent is None else self._parent.copy()
-        )
-
-    @contextmanager
-    def freeze(self) -> Iterator[None]:
-        previous = self._copy()
-        yield
-        self.data = previous.data
-        self._parent = previous._parent
+    def clone(self) -> "Scope":
+        return Scope(self.data, parent=self._parent)

classiq/qmod/builtins/operations.py

@@ -1,16 +1,12 @@
 import inspect
 import sys
-import warnings
 from collections.abc import Mapping
 from types import FrameType
 from typing import (
-    TYPE_CHECKING,
     Any,
     Callable,
     Final,
-    Optional,
     Union,
-    overload,
 )
 
 from classiq.interface.exceptions import ClassiqValueError
@@ -44,7 +40,8 @@ from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum, QScalar, QVar
+from classiq.qmod.generative import is_generative_mode
+from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QScalar, QVar
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_expandable import prepare_arg
 from classiq.qmod.symbolic_expr import SymbolicExpr
@@ -89,9 +86,10 @@ def if_(
         else_=_operand_to_body(else_, "else") if else_ != _MISSING_VALUE else [],  # type: ignore[arg-type]
         source_ref=source_ref,
     )
-    if_stmt.set_generative_block("then", then)
-    if callable(else_):
-        if_stmt.set_generative_block("else", else_)
+    if is_generative_mode():
+        if_stmt.set_generative_block("then", then)
+        if callable(else_):
+            if_stmt.set_generative_block("else", else_)
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(if_stmt)
 
 
@@ -109,9 +107,10 @@ def control(
         else_block=_operand_to_body(else_block, "else_block") if else_block else None,
         source_ref=source_ref,
     )
-    control_stmt.set_generative_block("body", stmt_block)
-    if else_block is not None:
-        control_stmt.set_generative_block("else_block", else_block)
+    if is_generative_mode():
+        control_stmt.set_generative_block("body", stmt_block)
+        if else_block is not None:
+            control_stmt.set_generative_block("else_block", else_block)
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(control_stmt)
 
 
@@ -161,22 +160,7 @@ def assign_amplitude(expression: SymbolicExpr, target_var: QScalar) -> None:
     )
 
 
-@overload
 def inplace_add(expression: SymbolicExpr, target_var: QScalar) -> None:
-    pass
-
-
-@overload
-def inplace_add(*, value: QNum, target: QNum) -> None:
-    pass
-
-
-def inplace_add(
-    expression: Optional[SymbolicExpr] = None,
-    target_var: Optional[QScalar] = None,
-    value: Optional[QNum] = None,
-    target: Optional[QNum] = None,
-) -> None:
     """
     Add an arithmetic expression to a quantum variable.
 
@@ -187,23 +171,6 @@ def inplace_add(
         target_var: A scalar quantum variable
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
-    if value is not None or target is not None:
-        warnings.warn(
-            "Parameters 'value' and 'target of function 'inplace_add' have "
-            "been renamed to 'expression' and 'target_var' respectively. Parameters "
-            "'value' and 'target' will no longer be supported starting on 02/12/24 at "
-            "the earliest.\nHint: Change `inplace_add(value=..., target=...)` to "
-            "`inplace_add(expression=..., target_var=...)` or `inplace_add(..., ...)`.",
-            category=DeprecationWarning,
-            stacklevel=2,
-        )
-    if value is not None:
-        expression = value
-    if target is not None:
-        target_var = target
-    if TYPE_CHECKING:
-        assert expression is not None
-        assert target_var is not None
     source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         ArithmeticOperation(
@@ -215,22 +182,7 @@ def inplace_add(
     )
 
 
-@overload
 def inplace_xor(expression: SymbolicExpr, target_var: QScalar) -> None:
-    pass
-
-
-@overload
-def inplace_xor(*, value: QNum, target: QNum) -> None:
-    pass
-
-
-def inplace_xor(
-    expression: Optional[SymbolicExpr] = None,
-    target_var: Optional[QScalar] = None,
-    value: Optional[QNum] = None,
-    target: Optional[QNum] = None,
-) -> None:
     """
     Bitwise-XOR a quantum variable with an arithmetic expression.
 
@@ -241,23 +193,6 @@ def inplace_xor(
         target_var: A scalar quantum variable
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
-    if value is not None or target is not None:
-        warnings.warn(
-            "Parameters 'value' and 'target of function 'inplace_xor' have "
-            "been renamed to 'expression' and 'target_var' respectively. Parameters "
-            "'value' and 'target' will no longer be supported starting on 02/12/24 at "
-            "the earliest.\nHint: Change `inplace_xor(value=..., target=...)` to "
-            "`inplace_xor(expression=..., target_var=...)` or `inplace_xor(..., ...)`.",
-            category=DeprecationWarning,
-            stacklevel=2,
-        )
-    if value is not None:
-        expression = value
-    if target is not None:
-        target_var = target
-    if TYPE_CHECKING:
-        assert expression is not None
-        assert target_var is not None
     source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         ArithmeticOperation(
@@ -282,8 +217,9 @@ def within_apply(
         action=_operand_to_body(apply, "apply"),
         source_ref=source_ref,
     )
-    within_apply_stmt.set_generative_block("within", within)
-    within_apply_stmt.set_generative_block("apply", apply)
+    if is_generative_mode():
+        within_apply_stmt.set_generative_block("within", within)
+        within_apply_stmt.set_generative_block("apply", apply)
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(within_apply_stmt)
 
 
@@ -313,7 +249,8 @@ def repeat(count: Union[SymbolicExpr, int], iteration: Callable[[int], None]) ->
         body=iteration_operand.body,
         source_ref=source_ref,
     )
-    repeat_stmt.set_generative_block("body", iteration)
+    if is_generative_mode():
+        repeat_stmt.set_generative_block("body", iteration)
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(repeat_stmt)
 
 
@@ -329,7 +266,8 @@ def power(
         body=_operand_to_body(stmt_block, "stmt_block"),
         source_ref=source_ref,
     )
-    power_stmt.set_generative_block("body", stmt_block)
+    if is_generative_mode():
+        power_stmt.set_generative_block("body", stmt_block)
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(power_stmt)
 
 
@@ -340,7 +278,8 @@ def invert(stmt_block: Union[QCallable, Callable[[], None]]) -> None:
     invert_stmt = Invert(
         body=_operand_to_body(stmt_block, "stmt_block"), source_ref=source_ref
     )
-    invert_stmt.set_generative_block("body", stmt_block)
+    if is_generative_mode():
+        invert_stmt.set_generative_block("body", stmt_block)
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(invert_stmt)
 
 

classiq/qmod/python_classical_type.py

@@ -1,6 +1,5 @@
 import dataclasses
 import inspect
-import sys
 from enum import EnumMeta
 from typing import (
     Optional,
@@ -16,16 +15,13 @@ from classiq.interface.generator.functions.classical_type import (
     Integer,
     Real,
 )
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 from classiq.interface.generator.functions.type_name import Enum, Struct
 
 from classiq.qmod.cparam import CArray, CBool, CInt, CReal
 from classiq.qmod.qmod_variable import get_type_hint_expr
 from classiq.qmod.utilities import version_portable_get_args
 
-if sys.version_info[0:2] >= (3, 9):
-    pass
-from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
-
 CARRAY_ERROR_MESSAGE = (
     "CArray accepts one or two generic parameters in the form "
     "`CArray[<element-type>]` or `CArray[<element-type>, <size>]`"

classiq/qmod/quantum_expandable.py

@@ -336,7 +336,8 @@ def prepare_arg(
                 pos_rename_params=val.infer_rename_params(),
                 body=val.body,
             )
-            qlambda.set_py_callable(val._py_callable)
+            if is_generative_mode():
+                qlambda.set_py_callable(val._py_callable)
             return qlambda
 
         if isinstance(val, QExpandable):

classiq/qmod/quantum_function.py

@@ -90,10 +90,10 @@ class QFunc(BaseQFunc):
 
     @property
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
-        return self._qmodule.native_defs.get(
-            self._py_callable.__name__,
-            infer_func_decl(self._py_callable, qmodule=self._qmodule),
-        )
+        name = self._py_callable.__name__
+        if hasattr(self._qmodule, "native_defs") and name in self._qmodule.native_defs:
+            return self._qmodule.native_defs[name]
+        return infer_func_decl(self._py_callable, qmodule=self._qmodule)
 
     def __call__(self, *args: Any, **kwargs: Any) -> None:
         super().__call__(*args, **kwargs)

{classiq-0.61.0.dist-info → classiq-0.62.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: classiq
-Version: 0.61.0
+Version: 0.62.0
 Summary: Classiq's Python SDK for quantum computing
 Home-page: https://classiq.io
 License: Proprietary
@@ -53,6 +53,7 @@ Requires-Dist: sympy (>=1.13.0,<2.0.0)
 Requires-Dist: tabulate (>=0.8.9,<1)
 Requires-Dist: torch (>=2.0,<3.0) ; extra == "qml"
 Requires-Dist: torchvision (>=0.15,<1.0) ; extra == "qml"
+Requires-Dist: tqdm (>=4.67.1,<5.0.0)
 Project-URL: Documentation, https://docs.classiq.io/
 Description-Content-Type: text/markdown
 

{classiq-0.61.0.dist-info → classiq-0.62.0.dist-info}/RECORD

@@ -39,12 +39,12 @@ classiq/applications/combinatorial_helpers/combinatorial_problem_utils.py,sha256
 classiq/applications/combinatorial_helpers/encoding_mapping.py,sha256=ULt_ZGzhiu2QMVv5L9Eo7VzsgPYmfUAiE1wG2_CnqQ8,3652
 classiq/applications/combinatorial_helpers/encoding_utils.py,sha256=Y75F2IHwjlwGshtqsfBG1U_S3cOl2eWu4zNZcCJ5nGE,3835
 classiq/applications/combinatorial_helpers/memory.py,sha256=b-VKPf8UiMxjQR5DICLoeV58noDgVTZz1iK218wvdNo,2283
-classiq/applications/combinatorial_helpers/optimization_model.py,sha256=Kb9FHLU4ZTsJecD-V8_QoSPuC78Z3Fd16Pu1zhhrRms,7032
+classiq/applications/combinatorial_helpers/optimization_model.py,sha256=5B805lVSVPtoNVg0yRWCLQ0hAWNOD7g2H3dTW8WxWcs,7225
 classiq/applications/combinatorial_helpers/pauli_helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 classiq/applications/combinatorial_helpers/pauli_helpers/pauli_sparsing.py,sha256=-vsJgA4Th3wrIxjNrG7Vv6ME8iZbw8rLuFZ99-tRpEc,1263
 classiq/applications/combinatorial_helpers/pauli_helpers/pauli_utils.py,sha256=kNDQicBmZzofaMsOWaOWptngmBAu-LE2wwSy2S9PGtE,1644
 classiq/applications/combinatorial_helpers/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-classiq/applications/combinatorial_helpers/pyomo_utils.py,sha256=DWdrSBlB1ZAVXwer_O1nL-Fh5VuMzYUIC-x6pZHhsmk,10595
+classiq/applications/combinatorial_helpers/pyomo_utils.py,sha256=rEBmu-E3nhoD9l4hKP7cLGSt9uUfgqTdQAj57k0zhdI,12202
 classiq/applications/combinatorial_helpers/solvers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 classiq/applications/combinatorial_helpers/sympy_utils.py,sha256=vz85CdjuM-EJmEH0kCTIy5RmPqj_S1g2lb417gMzsks,673
 classiq/applications/combinatorial_helpers/transformations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -58,7 +58,7 @@ classiq/applications/combinatorial_helpers/transformations/slack_variables.py,sh
 classiq/applications/combinatorial_optimization/__init__.py,sha256=FQv7Kga4aciJzuRuv9SiFLP2uTJdsYpzYZEaH3_cjsE,1050
 classiq/applications/combinatorial_optimization/combinatorial_optimization_config.py,sha256=jCN7iQJfEVIZE8sx60XzBrPBcBEOHVFXHhOZbq4auRw,618
 classiq/applications/combinatorial_optimization/combinatorial_optimization_model_constructor.py,sha256=Z22Xw9vhc-q03cm-WFnEgt0ML2_JrjHv5ow5kCjn50U,5314
-classiq/applications/combinatorial_optimization/combinatorial_problem.py,sha256=W4JsgvZsqpmjjrU6V2hwxVj9KBPbsIGyFyab_A6v100,6886
+classiq/applications/combinatorial_optimization/combinatorial_problem.py,sha256=APwtVlymPCKyEd1Tpe1tWELWj0xV8JMJZ_JWBS3MPPg,7963
 classiq/applications/combinatorial_optimization/examples/__init__.py,sha256=A0-j2W4dT6eyvRvIoUzK3trntkda3IBpX-tch8evi1M,1725
 classiq/applications/finance/__init__.py,sha256=1ntNgF5XLrAWhjvgncAdVIG0w80J8dmADySCK_xz2Tk,355
 classiq/applications/finance/finance_model_constructor.py,sha256=MQdrYHOYeWG0pMSflM23EskmIIPqZWJ1u-_HKEjrhGQ,6535
@@ -91,11 +91,11 @@ classiq/execution/__init__.py,sha256=91aJlyrskj_FLmT-2atwIucYKAKsg4o8ZOR15axBFPM
 classiq/execution/all_hardware_devices.py,sha256=KpLefEISE03FDdgFPGggXeG7NAxBW4090gN4272Dl-E,368
 classiq/execution/execution_session.py,sha256=j63Ty3Qsbmn1dxV9XfJfKizosUSfj0cwzOwgrCsJ2lE,17905
 classiq/execution/iqcc.py,sha256=0wy1tgQFcwqf9wFYyi6_OYRtx4s0AEViIAIvUkyKBmk,2429
-classiq/execution/jobs.py,sha256=d8GxbMgnvsqVFgTl6ZZzE0pLiXMLBp_lytk-XoWN31k,10980
+classiq/execution/jobs.py,sha256=cdZsnyedslwT_B3-g6NmlpBoW0ZV00gqdMPBdSjAork,11263
 classiq/execution/qnn.py,sha256=WGPvncz5uS2WxSY3-yBWt2LFiCk6Ug8WKWF-Kp-f7TM,2403
 classiq/executor.py,sha256=JukmHbvH43cXWBzr1-LPk5gDz4LItJncEUaghZwmldY,2686
 classiq/interface/__init__.py,sha256=cg7hD_XVu1_jJ1fgwmT0rMIoZHopNVeB8xtlmMx-E_A,83
-classiq/interface/_version.py,sha256=lhuM6Fz4nW7dXjc9hnP4mz50g36S4lTOQVI5n4786WY,197
+classiq/interface/_version.py,sha256=YgEZsFgTMHuaV7Cc1BAcjtBbx6-7_5r2f2UqhVB6NxE,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
@@ -104,11 +104,11 @@ classiq/interface/applications/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5
 classiq/interface/applications/qsvm.py,sha256=4dHVSZH--sv58SvxmpDHPh9JDr4qQUZbbGCeaEv6b1I,3408
 classiq/interface/ast_node.py,sha256=EE06R8KwRA-QkK44Ou9TmMxiaa8J60G9Z9qf9T76k_k,398
 classiq/interface/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-classiq/interface/backend/backend_preferences.py,sha256=m4W0RIuGAjhh7FkOGooAL0an7JlzNVwJpljR1NiLliA,20946
+classiq/interface/backend/backend_preferences.py,sha256=DuDfcUsN-5KOPKpjWr_zvM0UEBnrVX7NtdWY5OKXDVo,21743
 classiq/interface/backend/ionq/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 classiq/interface/backend/ionq/ionq_quantum_program.py,sha256=f8w1XvgIggaM_w9TF0_wkQHB3wamXg5kHMNsgtCsH3k,1235
 classiq/interface/backend/pydantic_backend.py,sha256=6Lv71R6k-_kl2NfO86BcCCHmnMNs9VNbOB56pNVVJyY,1596
-classiq/interface/backend/quantum_backend_providers.py,sha256=NWjfxwNxtY1tmBCktSVtOEkSDsdcIaHnkH0VQKJ-o8E,6575
+classiq/interface/backend/quantum_backend_providers.py,sha256=zMWV_-Y0lA8iGe2q4uHT5ODgfrEWDOu-XwMpXwdamuA,6673
 classiq/interface/chemistry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 classiq/interface/chemistry/ansatz_library.py,sha256=3ki3uaV77cUxUxUzDbn3mVhjvMoKejJ5bIR1kXpBT1k,360
 classiq/interface/chemistry/elements.py,sha256=Yy8L80SBVgmuKQyW-GlZKzwTqnP1O9po-FGFmKMJLRA,1181
@@ -212,6 +212,7 @@ classiq/interface/generator/compiler_keywords.py,sha256=2qH3291K2eaY6dZggXUr3nTG
 classiq/interface/generator/complex_type.py,sha256=tQ-2vUkXhpWz7dOMmcRTfd3tMJfXDvFkdy-KkQwe2FA,480
 classiq/interface/generator/constant.py,sha256=cLhRil6sof0UyYRU4lKdm_aBRcmmz7dtvX5bbNpb7N8,309
 classiq/interface/generator/control_state.py,sha256=eioObKxQt-g69NF3_-2QhLwO2mA5BIkFJnvqolwGFxk,2745
+classiq/interface/generator/copy.py,sha256=Gb_3JlVg-pXuMaGhLAzerHo2pEh7TUX6Dnxf7-Fa-CI,1372
 classiq/interface/generator/custom_ansatz.py,sha256=V_ezOlHUQDn5N6r-jE-W-xLeJHzV_cFUGZfN_BDPoP8,879
 classiq/interface/generator/distance.py,sha256=6u__ZB9VQvBrxePYm7yPKb_HtmITViPzF-F_I-qTgkE,1210
 classiq/interface/generator/entangler_params.py,sha256=wU5fzmTQ-sinEwsswdjsnX9_IupLp6Jn-2SXpqUcYRY,3108
@@ -237,7 +238,7 @@ classiq/interface/generator/expressions/type_proxy.py,sha256=2TSxdmmhnz78jxzPTqG
 classiq/interface/generator/finance.py,sha256=qlaBNQomMaxkbHjxXKZ2O9w9LK3im4_hyGPsigcbXT8,3968
 classiq/interface/generator/function_param_library.py,sha256=MzxtngUMoyRxxTZ3CRH_OR23Q5S-cxuxDsH0qwY-ZiM,630
 classiq/interface/generator/function_param_list.py,sha256=C__iX_ETyhm6B-ecfzFUQY7Tyz6aMVWx8_6ZUQuPg3M,503
-classiq/interface/generator/function_param_list_without_self_reference.py,sha256=HnqkeewfpRPLk_GzrKNa_6B4Du7uo1VFLIDbmb7WiHI,5520
+classiq/interface/generator/function_param_list_without_self_reference.py,sha256=wICu6BQ3iqV4Yvg19vInr6lklyeeISJ_NtDoFYMP9ZE,5592
 classiq/interface/generator/function_params.py,sha256=qo0JrN5nbNmh3nB2WUMftMS-c4o-oCh6KnljLBe7bLg,9677
 classiq/interface/generator/functions/__init__.py,sha256=HXHq8Fw2zHG3AYuRXrDEQdJ-CEFX7ibsNCp8czuCmmM,73
 classiq/interface/generator/functions/builtins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -272,7 +273,7 @@ classiq/interface/generator/model/__init__.py,sha256=iSabzwl3eN2iTRvdkRBmybAsy0o
 classiq/interface/generator/model/constraints.py,sha256=8LM-2NT8jARIzehBLmR2Z1hHwpQT-TwezWvnt82tTBE,2575
 classiq/interface/generator/model/model.py,sha256=VoAHk_wnL0GHd9BV2yjqGQR_fyDaCp5vlZOe7QJXtaE,2466
 classiq/interface/generator/model/preferences/__init__.py,sha256=KTNkU8hK3cpqzXvw_C1maxhBRTm1H53WUen1jJwZ0fQ,256
-classiq/interface/generator/model/preferences/preferences.py,sha256=gV0RWDsi92yCDR6i105X_sKWYZW8Guw3gtTT9KgeWfo,11136
+classiq/interface/generator/model/preferences/preferences.py,sha256=lwbnvqKUPVGOzUZxj0-4DzahvyH8GckTKgTGqL5kf8g,11171
 classiq/interface/generator/model/preferences/randomness.py,sha256=nAI8Fu9NQ0uJxuwIQCUDspJKMCQVHBbvPNqCTtrBEos,248
 classiq/interface/generator/model/quantum_register.py,sha256=_q5ASP_a5PrnpxN4aN2Yw00C1bh_KgIwiW1nTCRnuSw,8026
 classiq/interface/generator/noise_properties.py,sha256=onvXd_FeBznwu1AcOpAkL7-fo9Dc6tPcAIiL5Qxs2Ok,425
@@ -320,7 +321,7 @@ classiq/interface/generator/synthesis_metadata/synthesis_execution_data.py,sha25
 classiq/interface/generator/transpiler_basis_gates.py,sha256=4MHl6uI3Fa8bl1w_kGQC_2y_CQGxnKXbWSp5ezaw-w0,2397
 classiq/interface/generator/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 classiq/interface/generator/types/builtin_enum_declarations.py,sha256=kzrmQhyvIAO0FG1b4eHNVM7v0YYg5weXtLYYalejARE,2316
-classiq/interface/generator/types/compilation_metadata.py,sha256=2LJUeGWxuW3Yu_PYvN1Vk9MBDfNDd-blApP-iDst574,140
+classiq/interface/generator/types/compilation_metadata.py,sha256=TumieFiKwpt7tuje_CipXRJeg87YSr4hOg1uRr6cIU8,214
 classiq/interface/generator/types/enum_declaration.py,sha256=NLSkIANe33qubSDGmxROhNFZNuIDcJjRA-ZRuKhiZ5g,1712
 classiq/interface/generator/types/qstruct_declaration.py,sha256=Qw6cHW_elZmrs4UO0z7lgS7TWb0hEUEJ5Ur-Ko0bCR4,485
 classiq/interface/generator/types/struct_declaration.py,sha256=2qKVV-pdqeUGiwKh2-5W2Ci4z0aQG4TG91MuQ82fa_A,959
@@ -390,9 +391,9 @@ classiq/interface/source_reference.py,sha256=a-4Vdc511ux-0lDPDTRGAzouRWWtu4A3MPA
 classiq/model_expansions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 classiq/model_expansions/atomic_expression_functions_defs.py,sha256=cmue5ocNkPDo2KrryYxdzngow3BS7N1X0xOiu17roP4,8547
 classiq/model_expansions/capturing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-classiq/model_expansions/capturing/captured_vars.py,sha256=oEskFIK1JwxdE211toyYdRXCxFzInc0NLfvjs6X-jwE,12461
+classiq/model_expansions/capturing/captured_vars.py,sha256=q_-5WBk33LKKrizAkJRHejIXPny5RuZ1vRxTiNy6Kgc,12527
 classiq/model_expansions/capturing/mangling_utils.py,sha256=wfCsjP0pScZv9YP6JXq3oVhkS-lCFyUoZ9IROBHS3Ek,1858
-classiq/model_expansions/closure.py,sha256=s8N3b5QolH9acFFRArD19ESk-3Q6BtkBoYHokv6jbCw,6854
+classiq/model_expansions/closure.py,sha256=Va5xPaDEyzHmhBQYP5vp8vyY_6YMhQhLVVAGLzIcmEc,6709
 classiq/model_expansions/debug_flag.py,sha256=JWzl9FFq2CLcvTg_sh-K8Dp_xXvewsTuFKhPjTCrsrs,107
 classiq/model_expansions/evaluators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 classiq/model_expansions/evaluators/arg_type_match.py,sha256=nMRYHy2eMaG29NhlOdZWMg_qJHLWnKdW-FYrGxmRgjo,6155
@@ -404,28 +405,28 @@ classiq/model_expansions/evaluators/quantum_type_utils.py,sha256=5H5ri5RW6TLdXhn
 classiq/model_expansions/evaluators/type_type_match.py,sha256=3akZR86TAFKUyM5c5knCPSlraI3LQeWZXxXMTtmu0BI,3220
 classiq/model_expansions/expression_evaluator.py,sha256=WO6m6kkD1VHaqzEnt4PMQIAkDSal1wA-4VbbpjLj690,4382
 classiq/model_expansions/expression_renamer.py,sha256=rtAf-vvJhlwh-KCs2WgxdW4lP3UjA0vUtZeHcIoTwUM,2692
-classiq/model_expansions/function_builder.py,sha256=rw0KaY08HHONbtKK3ztq9y0V78ZXugk_LX2RljFOdEk,7441
-classiq/model_expansions/generative_functions.py,sha256=bSzi4-joQ6wKuEifOQwvuSlVnwiHXbJKikFvTHD4tBs,5622
-classiq/model_expansions/interpreter.py,sha256=r0Febz3dVQD8Cs7oVA-I8caje3nknI8gnOtimTrIO54,16829
+classiq/model_expansions/function_builder.py,sha256=TNUIYtZ9w8ELXc8a-4QWzXC_hL7EWMIhcg9-5o2JsiE,7575
+classiq/model_expansions/generative_functions.py,sha256=b-R7VS3miFWFQEXTiCf65CvwvoZGZyrzG87I0h8YfnQ,5630
+classiq/model_expansions/interpreter.py,sha256=0CV1QbxR_g5u88Pw4nLiw413b0KY0H-DdbYimdAGhGw,16093
 classiq/model_expansions/model_tables.py,sha256=C0ZhCF1GAmgCqkm6iTNO9-cj_YdwGpE8etKvVxWx1w8,3585
 classiq/model_expansions/quantum_operations/__init__.py,sha256=BMruLYFsir2nU9Du9PZBcQzQsgIc-4Zpkx8CJmvbL14,1040
 classiq/model_expansions/quantum_operations/bind.py,sha256=A1XPXnoexaKUlgUZSAn88SYXmXjo1G9-fCAJS67gM-c,2515
-classiq/model_expansions/quantum_operations/call_emitter.py,sha256=5hybpfS2PvdcjhOmTg11EHZE9qiJowyKSu3ZusT43Q4,10234
+classiq/model_expansions/quantum_operations/call_emitter.py,sha256=jGSJN0ZDMOHHJlNho4sNgpLamputh86hBXYXoQY78Hc,10324
 classiq/model_expansions/quantum_operations/classicalif.py,sha256=egWgO_xx8ohiA71KAo6glNxoQqEgH1MQQ9EbT-JQRV4,2027
 classiq/model_expansions/quantum_operations/control.py,sha256=cgNLu38Dez_cfDCzfintcjiYvyeXk3DZK0V6THqk5QA,12186
-classiq/model_expansions/quantum_operations/emitter.py,sha256=-bXRJ4mZnkwdWCeZGIcSONSMpHDcnfEtC2TY2XHbeCU,6686
+classiq/model_expansions/quantum_operations/emitter.py,sha256=uhi7OWy_Jan7lQGzaLFp4MnXu8BWb1kqweRij06s2ZA,6630
 classiq/model_expansions/quantum_operations/expression_operation.py,sha256=aW-0VmmWF5_0v4yWFNQdXoN9HiJQWJmWyIS3uDvjLWI,3962
 classiq/model_expansions/quantum_operations/inplace_binary_operation.py,sha256=BGBXV-NKFaL86qpdQZBKieLfrFajdtUipQ4AnyKIs9I,18213
 classiq/model_expansions/quantum_operations/invert.py,sha256=zsxUkakWgpoF07MHst03ahGXWQaulTDE0n_Zf9OV7Xs,1287
 classiq/model_expansions/quantum_operations/phase.py,sha256=PXbGRUHBVEXGzzDpeTjA1iAZSPuc66KMgw8De3tNFbE,7061
 classiq/model_expansions/quantum_operations/power.py,sha256=uSMMsA4n6FDhdFZY_S1d1Uo6tx5yGUotvcClsBCTFXg,2468
 classiq/model_expansions/quantum_operations/quantum_assignment_operation.py,sha256=7g-IOndlnRRC-Dk06l9YWAwBfHQiDN6DOs4jkR-lFc4,9141
-classiq/model_expansions/quantum_operations/quantum_function_call.py,sha256=XNSoHv-l6XYl4OdBgEQaVp-IIb7RzACfVzi1woFMWPk,989
+classiq/model_expansions/quantum_operations/quantum_function_call.py,sha256=9pATOFHUz2Co9fVBXqgaWoWPPgR-h_C0HfWC57e5-C8,970
 classiq/model_expansions/quantum_operations/repeat.py,sha256=2gvc6OwU6Tz6qwRFhGJ11Rjju4Xw1CaRoV0hnH4KB5c,2205
-classiq/model_expansions/quantum_operations/shallow_emitter.py,sha256=-4DF-rJVo65Z4NU0ZMu0Iycf9ZMMeYM9IlBg42Gw_OE,6160
+classiq/model_expansions/quantum_operations/shallow_emitter.py,sha256=hTAtlIND2Nw7Dwzw6y52pgNdEFItYTbTy5yjupzaVZY,6361
 classiq/model_expansions/quantum_operations/variable_decleration.py,sha256=OG_uWndzpPX4rJ3ij_7iOtcS779ubS-Uo2RT1GHdR60,1199
 classiq/model_expansions/quantum_operations/within_apply.py,sha256=IbQ9sLWGzn-B_W-oHgdynyrnh2Sl4ZTksEETzeKQ508,982
-classiq/model_expansions/scope.py,sha256=oE8wGv0kgoj2Qd-x8SVVPcr1W7t3dOKMarqgVyVPvls,7876
+classiq/model_expansions/scope.py,sha256=D0EPsmIuIYfVVslb47L7JkoWle4iv47uRrq6V2r3GJQ,7594
 classiq/model_expansions/scope_initialization.py,sha256=JbDKMGm7p-wNJjUBIR1Fy9LAs_w2bViyJHr2xivNYRI,5245
 classiq/model_expansions/sympy_conversion/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 classiq/model_expansions/sympy_conversion/arithmetics.py,sha256=7ZKg1C92wUdxtFhrT4VuI9mNvH2a1z1R8lbWYFhYczc,1116
@@ -470,7 +471,7 @@ classiq/qmod/builtins/functions/state_preparation.py,sha256=7fUA2J6tz2nx4Xrac-WL
 classiq/qmod/builtins/functions/swap_test.py,sha256=7-QLxSJhBjkxp7Kvdf0kaxOa2GwLJ_eQNYo4NgGdjcE,1112
 classiq/qmod/builtins/functions/utility_functions.py,sha256=PjIe1gfyoh1rp1nWHt_gz7YL4c6JgPZy0Y3ZEnnz4sE,1150
 classiq/qmod/builtins/functions/variational.py,sha256=wQDkQ3lv2BxWhCJUJd4XioCCAkB-GoeH1mZDiFVa5A4,1776
-classiq/qmod/builtins/operations.py,sha256=O3UMHTZKPZ1GkvDfYHTIUVyfKU47MZW3jIyobXlmuZA,15628
+classiq/qmod/builtins/operations.py,sha256=ubmd_Nw7IVYorGooQ8ZwRx8OagE2pMVk6bsJO40SuDY,13712
 classiq/qmod/builtins/structs.py,sha256=OpPDFcnZkIo1N9EQVXjqDkEk46vtzA8FmcCv2KarJFg,2913
 classiq/qmod/cfunc.py,sha256=e3zWNEloBBPy-wJaGI1K5cdNFbd3oq0o4TUY2YDr6ks,1087
 classiq/qmod/classical_function.py,sha256=iHm6T719PUZQPwuNSkouaMA8J9yHrrHUpP-2AQjsA5g,1088
@@ -486,14 +487,14 @@ classiq/qmod/native/pretty_printer.py,sha256=BMqoY5TlAWR3cxhbpJbZWX3D2Tc5cal_yqm
 classiq/qmod/pretty_print/__init__.py,sha256=jhR0cpXumOJnyb-zWnvMLpEuUOYPnnJ7DJmV-Zxpy1I,132
 classiq/qmod/pretty_print/expression_to_python.py,sha256=QoRP817CFEp3Ad3Q3hxWW-hbVzWQbHQIGUHjZkpZDm8,7480
 classiq/qmod/pretty_print/pretty_printer.py,sha256=NIKcJmleFz3FIe7MvfaL_xxx0Bo1kf4w0N4BrCzkHGo,23213
-classiq/qmod/python_classical_type.py,sha256=S_CbuxMHmYDgYcT31kCIy1xjhWvnAHHVJNWZ6lUPV8w,2513
+classiq/qmod/python_classical_type.py,sha256=aU7QYrz7_ZRjmgjjS1DPq3tPm3SzuqZoxlJ4ZuKX0XI,2456
 classiq/qmod/qfunc.py,sha256=pDyGqHhITayNFvcns-IknAG_KHTqlqHaQfHRF25Yc44,1949
 classiq/qmod/qmod_constant.py,sha256=YawkwhhOLqFyFUyhE13Q_zCnex_Ki46hePRwGJmr5oU,4853
 classiq/qmod/qmod_parameter.py,sha256=PpK4rzY0Hszgbzr_lclROcZ7JPqnhDJBYsSQkUjkcs8,4294
 classiq/qmod/qmod_variable.py,sha256=xOYCvvLx0OOC1axFE3_tyQb1c68LumpCp0--cGDb8hE,24059
 classiq/qmod/quantum_callable.py,sha256=sthlH5UJyJsdOxpCW3_EW3JFIYd0r1K3Zec1CDbC2-0,2451
-classiq/qmod/quantum_expandable.py,sha256=IUOXXZAD1miiO5ceMlLSobrp3akrRmy2b-msHqVp9qU,16121
-classiq/qmod/quantum_function.py,sha256=6TljYxrT5vGSGQWRFLK_dhnXxaZsqFbjv2wl7nlxaC4,10075
+classiq/qmod/quantum_expandable.py,sha256=3dTRcm3LZ0YnUc1NRUkOEsRTuiGJcrCMK5qzcCMR9mg,16162
+classiq/qmod/quantum_function.py,sha256=qoo_UYMAs11sD17hlkmOlmJmJqEwA5AJr6wq7F0jSNs,10162
 classiq/qmod/semantics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 classiq/qmod/semantics/annotation.py,sha256=0IeRymMK20sPHzbs7EzGoqhZICQmR6-gXR3SS9sr9OE,1255
 classiq/qmod/semantics/error_manager.py,sha256=KAnNaQE0YarkXTQ0du3mvCqGCbbH-d81sv2Ti-NpkL4,2783
@@ -513,6 +514,6 @@ classiq/qmod/type_attribute_remover.py,sha256=NZmTXAsngWqthXjE8n-n6yE72fiWTFM12-
 classiq/qmod/utilities.py,sha256=z_VnIRmOYTWjJp2UlOcWK0rQRtMqysmP_Gr6WYY_nak,2734
 classiq/qmod/write_qmod.py,sha256=Oo-j_rSfcmzC5MOn0Vq334vv_OTvdD4P7K9pv-gbo8c,1833
 classiq/synthesis.py,sha256=WLk3wpX_xPiAMstF9PGMO5SWVb_qqa1sN2Nj3MekX34,8113
-classiq-0.61.0.dist-info/METADATA,sha256=QZbAld2MTI_VpR6a-LF1wHPudOegBbBUmMMW9usPmqk,3459
-classiq-0.61.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-classiq-0.61.0.dist-info/RECORD,,
+classiq-0.62.0.dist-info/METADATA,sha256=065h6fe5pa0am7JB8789apehdM0qBfQcUtL55KXEzKY,3497
+classiq-0.62.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+classiq-0.62.0.dist-info/RECORD,,