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

classiq/model_expansions/interpreter.py

@@ -32,7 +32,7 @@ from classiq.interface.model.handle_binding import (
 )
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
 from classiq.interface.model.invert import Invert
-from classiq.interface.model.model import Model
+from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.power import Power
@@ -93,11 +93,14 @@ from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.model_expansions.scope_initialization import (
     add_constants_to_scope,
     add_entry_point_params_to_scope,
+    add_functions_to_scope,
+    add_generative_functions_to_scope,
     get_main_renamer,
     init_top_level_scope,
 )
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
 from classiq.qmod.builtins.functions import permute
+from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
 from classiq.qmod.quantum_function import GenerativeQFunc
 from classiq.qmod.semantics.error_manager import ErrorManager
 
@@ -107,22 +110,28 @@ class Interpreter:
         self,
         model: Model,
         generative_functions: Optional[list[GenerativeQFunc]] = None,
-        is_frontend: bool = False,
+        is_normalizer: bool = False,
+        is_shallow: bool = False,
     ) -> None:
-        self._is_frontend = is_frontend
+        self._is_normalizer = is_normalizer
+        self._is_shallow = is_shallow
         self._model = model
         self._top_level_scope = Scope()
-        self._builder = OperationBuilder(self._top_level_scope)
+        self._counted_name_allocator = CountedNameAllocator()
+        self._builder = OperationBuilder(
+            self._top_level_scope, self._counted_name_allocator
+        )
         self._expanded_functions: dict[str, NativeFunctionDefinition] = {}
 
+        init_top_level_scope(model, generative_functions or [], self._top_level_scope)
         self._main_renamer: Optional[ExpressionRenamer] = (
-            get_main_renamer(self._model.functions) if self._is_frontend else None
+            get_main_renamer(self._get_function_declarations())
+            if self._is_normalizer
+            else None
+        )
+        self._functions_compilation_metadata: dict[str, CompilationMetadata] = dict(
+            self._model.functions_compilation_metadata
         )
-
-        if generative_functions is None:
-            generative_functions = []
-        self._generative_functions = generative_functions
-        init_top_level_scope(model, generative_functions, self._top_level_scope)
         self._expanded_functions_compilation_metadata: dict[
             str, CompilationMetadata
         ] = defaultdict(CompilationMetadata)
@@ -130,13 +139,23 @@ class Interpreter:
         self._error_manager: ErrorManager = ErrorManager()
 
     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,
+        main_func = self._top_level_scope[MAIN_FUNCTION_NAME].value
+        closure_constructor: Any
+        if isinstance(main_func, GenerativeFunctionClosure):
+            closure_constructor = GenerativeFunctionClosure
+            extra_args = {
+                "generative_blocks": {"body": main_func.generative_blocks["body"]}
+            }
+        else:
+            closure_constructor = FunctionClosure
+            extra_args = {"body": main_func.body}
+        main_closure = closure_constructor.create(
+            name=main_func.name,
+            positional_arg_declarations=main_func.positional_arg_declarations,
             scope=Scope(parent=self._top_level_scope),
             expr_renamer=self._main_renamer,
             _depth=0,
+            **extra_args,
         )
 
         add_entry_point_params_to_scope(
@@ -170,9 +189,9 @@ class Interpreter:
             execution_preferences=self._model.execution_preferences,
             functions=list(self._expanded_functions.values()),
             constants=self._model.constants,
-            enums=self._model.enums,
-            types=self._model.types,
-            qstructs=self._model.qstructs,
+            enums=list(QMODULE.enum_decls.values()),
+            types=list(QMODULE.type_decls.values()),
+            qstructs=list(QMODULE.qstruct_decls.values()),
             debug_info=self._model.debug_info,
             functions_compilation_metadata=self._expanded_functions_compilation_metadata,
         )
@@ -196,7 +215,9 @@ class Interpreter:
             for idx, param in enumerate(function.func_decl.positional_arg_declarations)
         ]
         func_decl = NamedParamsQuantumFunctionDeclaration(
-            name=function.func_decl.name or "<lambda>",
+            name=self._counted_name_allocator.allocate(
+                function.func_decl.name or "<lambda>"
+            ),
             positional_arg_declarations=renamed_params,
         )
 
@@ -275,7 +296,7 @@ class Interpreter:
 
     @emit.register
     def emit_quantum_assignment_operation(self, op: QuantumAssignmentOperation) -> None:
-        if self._is_frontend:
+        if self._is_normalizer:
             ShallowEmitter(
                 self, "assignment_operation", components=["expression", "result_var"]
             ).emit(op)
@@ -284,7 +305,7 @@ class Interpreter:
 
     @emit.register
     def emit_inplace_binary_operation(self, op: InplaceBinaryOperation) -> None:
-        if self._is_frontend:
+        if self._is_normalizer:
             ShallowEmitter(
                 self, "inplace_binary_operation", components=["target", "value"]
             ).emit(op)
@@ -303,7 +324,7 @@ class Interpreter:
 
     @emit.register
     def emit_within_apply(self, within_apply: WithinApply) -> None:
-        if self._is_frontend:
+        if self._is_normalizer:
             ShallowEmitter(
                 self,
                 WITHIN_APPLY_NAME,
@@ -314,7 +335,7 @@ class Interpreter:
 
     @emit.register
     def emit_invert(self, invert: Invert) -> None:
-        if self._is_frontend:
+        if self._is_normalizer:
             ShallowEmitter(self, INVERT_OPERATOR_NAME, components=["body"]).emit(invert)
         else:
             InvertEmitter(self).emit(invert)
@@ -325,7 +346,7 @@ class Interpreter:
 
     @emit.register
     def emit_control(self, control: Control) -> None:
-        if self._is_frontend:
+        if self._is_normalizer:
             ShallowEmitter(
                 self,
                 CONTROL_OPERATOR_NAME,
@@ -336,7 +357,7 @@ class Interpreter:
 
     @emit.register
     def emit_power(self, power: Power) -> None:
-        if self._is_frontend:
+        if self._is_normalizer:
             ShallowEmitter(
                 self, CONTROL_OPERATOR_NAME, components=["power", "body"]
             ).emit(power)
@@ -345,7 +366,7 @@ class Interpreter:
 
     @emit.register
     def emit_phase(self, phase: PhaseOperation) -> None:
-        if self._is_frontend:
+        if self._is_normalizer:
             ShallowEmitter(self, "phase", components=["expression", "theta"]).emit(
                 phase
             )
@@ -370,9 +391,11 @@ class Interpreter:
     def _expand_operation(self, operation: Closure) -> OperationContext:
         with self._builder.operation_context(operation) as context:
             if isinstance(operation, FunctionClosure) and (
-                self._expanded_functions.get(operation.closure_id) is not None
+                (func_def := self._expanded_functions.get(operation.closure_id))
+                is not None
             ):
-                pass
+                captured_vars = self._top_level_scope[func_def.name].value.captured_vars
+                operation.captured_vars.update(captured_vars)
             elif isinstance(operation, FunctionClosure) and operation.name == "permute":
                 # special expansion since permute is generative
                 self._expand_permute()
@@ -403,11 +426,50 @@ class Interpreter:
         self._expand_block(calls, "body")
 
     def _get_function_declarations(self) -> Sequence[QuantumFunctionDeclaration]:
-        return (
-            self._model.functions
-            + [gen_func.func_decl for gen_func in self._generative_functions]
-            + list(self._expanded_functions.values())
-        )
+        return [
+            QuantumFunctionDeclaration(
+                name=func_closure.name,
+                positional_arg_declarations=func_closure.positional_arg_declarations,
+            )
+            for func in self._top_level_scope.values()
+            if isinstance(func_closure := func.value, FunctionClosure)
+        ]
 
     def add_constant(self, constant: Constant) -> None:
         add_constants_to_scope([constant], self._top_level_scope)
+
+    def update_declarative_functions(
+        self,
+        functions: dict[str, NativeFunctionDefinition],
+        qmodule: ModelStateContainer,
+    ) -> None:
+        add_functions_to_scope(list(functions.values()), self._top_level_scope)
+        for dec_func_name in functions:
+            if dec_func_name in qmodule.functions_compilation_metadata:
+                self._functions_compilation_metadata[dec_func_name] = (
+                    qmodule.functions_compilation_metadata[dec_func_name]
+                )
+
+    def update_generative_functions(
+        self, generative_functions: dict[str, GenerativeQFunc]
+    ) -> None:
+        add_generative_functions_to_scope(
+            list(generative_functions.values()), self._top_level_scope
+        )
+        for name, gen_func in generative_functions.items():
+            if gen_func.compilation_metadata is not None:
+                self._functions_compilation_metadata[name] = (
+                    gen_func.compilation_metadata
+                )
+
+    def add_purely_declarative_function(self, function: FunctionClosure) -> None:
+        functions_to_add = [function.name] + QMODULE.function_dependencies[
+            function.name
+        ]
+        for func in functions_to_add:
+            if func not in self._expanded_functions and func in QMODULE.native_defs:
+                self._expanded_functions[func] = QMODULE.native_defs[func]
+                if func in QMODULE.functions_compilation_metadata:
+                    self._expanded_functions_compilation_metadata[func] = (
+                        QMODULE.functions_compilation_metadata[func]
+                    )

classiq/model_expansions/model_tables.py

@@ -78,10 +78,14 @@ class SymbolTable:
     @classmethod
     def init_user_enums(cls, user_enums: list[EnumDeclaration]) -> None:
         cls.enum_table = EnumTable(user_enums)
+        QMODULE.enum_decls = {enum_decl.name: enum_decl for enum_decl in user_enums}
 
     @classmethod
     def init_user_types(cls, user_types: list[StructDeclaration]) -> None:
         cls.type_table = StructTable(user_types)
+        QMODULE.type_decls = {
+            struct_decl.name: struct_decl for struct_decl in user_types
+        }
 
     @classmethod
     def init_user_qstructs(cls, user_qstructs: list[QStructDeclaration]) -> None:

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -8,6 +8,9 @@ from typing import (
 )
 
 from classiq.interface.debug_info.debug_info import FunctionDebugInfo
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
 from classiq.interface.generator.generated_circuit_data import OperationLevel
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
@@ -20,6 +23,10 @@ from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
 )
+from classiq.interface.model.quantum_lambda_function import (
+    OperandIdentifier,
+    QuantumLambdaFunction,
+)
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
@@ -28,7 +35,7 @@ from classiq.interface.model.variable_declaration_statement import (
 from classiq.model_expansions.capturing.captured_vars import (
     validate_args_are_not_propagated,
 )
-from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.closure import FunctionClosure, GenerativeClosure
 from classiq.model_expansions.evaluators.argument_types import (
     add_information_from_output_arguments,
 )
@@ -45,6 +52,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.qmod.builtins.functions import allocate, free
+from classiq.qmod.model_state_container import QMODULE
 
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreter import Interpreter
@@ -65,7 +73,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         self, name: str, body: Sequence[QuantumStatement]
     ) -> QuantumFunctionCall:
         wrapping_function = FunctionClosure.create(
-            name=name,
+            name=self._counted_name_allocator.allocate(name),
             body=body,
             scope=Scope(parent=self._current_scope),
             is_lambda=True,
@@ -98,6 +106,13 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         )
         new_positional_arg_decls = new_declaration.positional_arg_declarations
         is_atomic = function.is_atomic
+        if (
+            self._interpreter._is_shallow
+            and self._is_function_purely_declarative(function)
+            and self._are_args_purely_declarative(args)
+        ):
+            is_atomic = True
+            self._interpreter.add_purely_declarative_function(function)
         new_function_name = function.name
         if not is_atomic:  # perform monomorphization per interpreted parameters set
             self._add_params_to_scope(
@@ -253,3 +268,47 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
                 evaluated_args,
             ),
         )
+
+    def _is_function_purely_declarative(self, function: FunctionClosure) -> bool:
+        if function.name not in QMODULE.native_defs:
+            return False
+
+        if isinstance(function, GenerativeClosure):
+            return False
+
+        if any(
+            not param.quantum_type.is_instantiated
+            for param in function.positional_arg_declarations
+            if isinstance(param, PortDeclaration)
+            and param.direction == PortDeclarationDirection.Output
+        ):
+            return False
+
+        dependencies = QMODULE.function_dependencies[function.name]
+        return self._are_identifiers_purely_declarative(dependencies)
+
+    def _are_args_purely_declarative(self, args: list[ArgValue]) -> bool:
+        if any(
+            isinstance(arg, (OperandIdentifier, QuantumLambdaFunction))
+            or (
+                isinstance(arg, list)
+                and any(
+                    isinstance(item, (OperandIdentifier, QuantumLambdaFunction))
+                    for item in arg
+                )
+            )
+            for arg in args
+        ):
+            return False
+
+        dependencies = [arg for arg in args if isinstance(arg, str)]
+        dependencies += [
+            cast(str, item) for arg in args if isinstance(arg, list) for item in arg
+        ]
+        return self._are_identifiers_purely_declarative(dependencies)
+
+    def _are_identifiers_purely_declarative(self, dependencies: list[str]) -> bool:
+        return not any(
+            isinstance(self._current_scope[dep].value, GenerativeClosure)
+            for dep in dependencies
+        )

classiq/model_expansions/quantum_operations/classicalif.py

@@ -45,7 +45,7 @@ class ClassicalIfEmitter(CallEmitter[ClassicalIf]):
             return
 
         then_else_func = FunctionClosure.create(
-            name=op_name,
+            name=self._counted_name_allocator.allocate("then" if condition else "else"),
             body=body,
             scope=Scope(parent=self._current_scope),
             is_lambda=True,

classiq/model_expansions/quantum_operations/control.py

@@ -1,5 +1,3 @@
-from typing import cast
-
 from sympy import Equality
 from sympy.logic.boolalg import Boolean
 from typing_extensions import TypeGuard
@@ -55,6 +53,9 @@ from classiq.qmod.builtins.functions.standard_gates import X
 
 class ControlEmitter(ExpressionOperationEmitter[Control]):
     def emit(self, control: Control, /) -> None:
+        validate_args_are_not_propagated(
+            extract_handles(control.expression), extract_handles(control.body)
+        )
         condition = control.expression
         arrays_with_subscript = self.split_symbols(
             condition, self._counted_name_allocator.allocate
@@ -117,10 +118,6 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
             scope=Scope(parent=self._current_scope),
         )
         context = self._expand_operation(control_operation)
-        validate_args_are_not_propagated(
-            control.var_handles,
-            extract_handles([block.statements for block in context.blocks.values()]),
-        )
         self._update_control_state(control)
         self.emit_statement(
             control.model_copy(update=dict(body=context.statements("body")))
@@ -130,10 +127,6 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
         wrapping_function = self._create_expanded_wrapping_function(
             CONTROL_OPERATOR_NAME, control.body
         )
-        validate_args_are_not_propagated(
-            control.var_handles,
-            cast(list[HandleBinding], wrapping_function.positional_args),
-        )
         self._update_control_state(control)
         self.emit_statement(control.model_copy(update=dict(body=[wrapping_function])))
 

classiq/model_expansions/quantum_operations/emitter.py

@@ -54,7 +54,7 @@ class Emitter(Generic[QuantumStatementT]):
             self._interpreter._expanded_functions_compilation_metadata
         )
         self._functions_compilation_metadata = (
-            self._interpreter._model.functions_compilation_metadata
+            self._interpreter._functions_compilation_metadata
         )
 
     @abstractmethod

classiq/model_expansions/quantum_operations/quantum_assignment_operation.py

@@ -123,8 +123,7 @@ class QuantumAssignmentOperationEmitter(
         self, op: ArithmeticOperation
     ) -> tuple[ArithmeticOperation, Expression, bool]:
         if (
-            self._interpreter._is_frontend
-            or op.operation_kind
+            op.operation_kind
             not in (
                 ArithmeticOperationKind.Assignment,
                 ArithmeticOperationKind.InplaceXor,

classiq/model_expansions/quantum_operations/repeat.py

@@ -22,10 +22,11 @@ class RepeatEmitter(CallEmitter[Repeat]):
             raise ClassiqExpansionError(
                 f"repeat count must be non-negative, got {count}"
             )
+        op_name = self._counted_name_allocator.allocate(REPEAT_OPERATOR_NAME)
         for i in range(count):
-            self._emit_iteration(repeat, i)
+            self._emit_iteration(repeat, i, op_name)
 
-    def _emit_iteration(self, repeat: Repeat, i: int) -> None:
+    def _emit_iteration(self, repeat: Repeat, i: int, op_name: str) -> None:
         closure_constructor: type[FunctionClosure]
         extra_args: dict
         if repeat.is_generative():
@@ -41,7 +42,7 @@ class RepeatEmitter(CallEmitter[Repeat]):
             closure_constructor = FunctionClosure
             extra_args = {}
         iteration_function = closure_constructor.create(
-            name=REPEAT_OPERATOR_NAME,
+            name=op_name,
             positional_arg_declarations=[
                 ClassicalParameterDeclaration(
                     name=repeat.iter_var, classical_type=Integer()

classiq/model_expansions/scope.py

@@ -163,8 +163,14 @@ class Evaluated:  # FIXME: Merge with EvaluatedExpression if possible
         return int(self.value)
 
     def emit(self) -> ArgValue:
-        if isinstance(self.value, QuantumSymbol):
+        from classiq.model_expansions.closure import FunctionClosure
+
+        if isinstance(self.value, (QuantumSymbol, FunctionClosure)):
             return self.value.emit()
+        if isinstance(self.value, list) and all(
+            isinstance(item, FunctionClosure) for item in self.value
+        ):
+            return [item.emit() for item in self.value]
 
         ret = Expression(expr=evaluated_to_str(self.value))
         ret._evaluated_expr = EvaluatedExpression(value=self.value)

classiq/model_expansions/scope_initialization.py

@@ -1,4 +1,5 @@
 from collections.abc import Sequence
+from typing import TYPE_CHECKING
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.constant import Constant
@@ -12,7 +13,11 @@ from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
-from classiq.interface.model.quantum_function_declaration import PositionalArg
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+    PositionalArg,
+    QuantumFunctionDeclaration,
+)
 
 from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
 from classiq.model_expansions.evaluators.classical_expression import (
@@ -32,12 +37,14 @@ from classiq.qmod.quantum_function import GenerativeQFunc
 
 
 def get_main_renamer(
-    functions: Sequence[NativeFunctionDefinition],
+    func_decls: Sequence[QuantumFunctionDeclaration],
 ) -> ExpressionRenamer:
-    for func in functions:
-        if func.name == MAIN_FUNCTION_NAME:
+    for func_decl in func_decls:
+        if func_decl.name == MAIN_FUNCTION_NAME:
+            if TYPE_CHECKING:
+                assert isinstance(func_decl, NamedParamsQuantumFunctionDeclaration)
             return ExpressionRenamer.from_positional_arg_declarations(
-                func.positional_arg_declarations, CPARAM_EXECUTION_SUFFIX
+                func_decl.positional_arg_declarations, CPARAM_EXECUTION_SUFFIX
             )
     return ExpressionRenamer(var_mapping={})
 
@@ -49,32 +56,34 @@ def add_constants_to_scope(constants: list[Constant], scope: Scope) -> None:
         )
 
 
-def _add_functions_to_scope(
-    functions: list[NativeFunctionDefinition], scope: Scope
+def add_functions_to_scope(
+    functions: Sequence[NativeFunctionDefinition], scope: Scope
 ) -> None:
     for function in functions:
-        scope[function.name] = Evaluated(
-            value=FunctionClosure.create(
-                name=function.name,
-                positional_arg_declarations=function.positional_arg_declarations,
-                body=function.body,
-                scope=Scope(parent=scope),
+        if function.name not in scope:
+            scope[function.name] = Evaluated(
+                value=FunctionClosure.create(
+                    name=function.name,
+                    positional_arg_declarations=function.positional_arg_declarations,
+                    body=function.body,
+                    scope=Scope(parent=scope),
+                )
             )
-        )
 
 
-def _add_generative_functions_to_scope(
-    functions: list[GenerativeQFunc], scope: Scope
+def add_generative_functions_to_scope(
+    functions: Sequence[GenerativeQFunc], scope: Scope
 ) -> None:
     for function in functions:
-        scope[function.func_decl.name] = Evaluated(
-            value=GenerativeFunctionClosure.create(
-                name=function.func_decl.name,
-                positional_arg_declarations=function.func_decl.positional_arg_declarations,
-                scope=Scope(parent=scope),
-                generative_blocks={"body": function},
+        if function.func_decl.name not in scope:
+            scope[function.func_decl.name] = Evaluated(
+                value=GenerativeFunctionClosure.create(
+                    name=function.func_decl.name,
+                    positional_arg_declarations=function.func_decl.positional_arg_declarations,
+                    scope=Scope(parent=scope),
+                    generative_blocks={"body": function},
+                )
             )
-        )
 
 
 def _init_builtins_scope(scope: Scope) -> None:
@@ -129,7 +138,7 @@ def add_entry_point_params_to_scope(
 def init_top_level_scope(
     model: Model, generative_functions: list[GenerativeQFunc], scope: Scope
 ) -> None:
-    _add_functions_to_scope(model.functions, scope)
-    _add_generative_functions_to_scope(generative_functions, scope)
+    add_generative_functions_to_scope(generative_functions, scope)
+    add_functions_to_scope(model.functions, scope)
     add_constants_to_scope(model.constants, scope)
     _init_builtins_scope(scope)

classiq/model_expansions/transformers/var_splitter.py

@@ -1,7 +1,7 @@
 import ast
 from dataclasses import dataclass
 from itertools import chain
-from typing import TYPE_CHECKING, Callable, TypeVar, cast
+from typing import TYPE_CHECKING, Callable, Optional, TypeVar, cast
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -14,6 +14,7 @@ from classiq.interface.model.handle_binding import (
     HandleBinding,
     NestedHandleBinding,
     SlicedHandleBinding,
+    SubscriptHandleBinding,
 )
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumExpressionOperation,
@@ -125,12 +126,7 @@ class VarSplitter:
             raise ClassiqExpansionError(
                 f"Could not determine the length of quantum array " f"{symbol.handle}."
             )
-        target_slices = {
-            target_part.start.to_int_value(): target_part.end.to_int_value()
-            for target_part in target_parts
-            if isinstance(target_part, SlicedHandleBinding)
-            and symbol.handle == target_part.base_handle
-        }
+        target_slices = self._get_target_slices(symbol, target_parts)
 
         symbol_parts: list[QuantumSymbol] = []
         idx = 0
@@ -151,6 +147,60 @@ class VarSplitter:
 
         return symbol_parts
 
+    def _get_target_slices(
+        self, symbol: QuantumSymbol, target_parts: list[HandleBinding]
+    ) -> dict[int, int]:
+        if TYPE_CHECKING:
+            assert isinstance(symbol.quantum_type, QuantumBitvector)
+        target_items = {
+            idx
+            for idx in range(symbol.quantum_type.length_value)
+            for target_part in target_parts
+            if target_part
+            in SubscriptHandleBinding(
+                base_handle=symbol.handle, index=Expression(expr=str(idx))
+            )
+        }
+        target_slices = {
+            target_part.start.to_int_value(): target_part.end.to_int_value()
+            for target_part in target_parts
+            if isinstance(target_part, SlicedHandleBinding)
+            and symbol.handle == target_part.base_handle
+        }
+        self._add_unused_indices_as_slices(symbol, target_items, target_slices)
+        return target_slices
+
+    @staticmethod
+    def _add_unused_indices_as_slices(
+        symbol: QuantumSymbol, target_items: set[int], target_slices: dict[int, int]
+    ) -> None:
+        if TYPE_CHECKING:
+            assert isinstance(symbol.quantum_type, QuantumBitvector)
+        last_unused_idx: Optional[int] = None
+        array_length = symbol.quantum_type.length_value
+        idx = 0
+
+        while idx < array_length:
+            if (
+                idx in target_items or idx in target_slices
+            ) and last_unused_idx is not None:
+                target_slices[last_unused_idx] = idx
+                last_unused_idx = None
+
+            if idx in target_slices:
+                if target_slices[idx] <= idx:
+                    raise ClassiqInternalExpansionError
+                idx = target_slices[idx]
+                continue
+
+            if idx not in target_items and last_unused_idx is None:
+                last_unused_idx = idx
+
+            idx += 1
+
+        if last_unused_idx is not None:
+            target_slices[last_unused_idx] = array_length
+
     def _get_struct_parts(
         self, symbol: QuantumSymbol, target_parts: list[HandleBinding]
     ) -> list[QuantumSymbol]:

classiq/open_library/__init__.py

@@ -0,0 +1,4 @@
+from .functions import *  # noqa: F403
+from .functions import __all__ as _functions_all
+
+__all__ = _functions_all