classiq 0.47.0__py3-none-any.whl → 0.48.1__py3-none-any.whl

classiq/model_expansions/generative_functions.py

@@ -1,51 +1,82 @@
-from typing import TYPE_CHECKING, Any, List
+from typing import TYPE_CHECKING, Any, List, Mapping
 
+from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.qmod_struct_instance import (
     QmodStructInstance,
 )
 from classiq.interface.generator.functions.type_name import Struct
+from classiq.interface.generator.visitor import Visitor
 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
+from classiq.interface.model.quantum_function_call import ArgValue, QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     PositionalArg,
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
+from classiq.interface.model.quantum_lambda_function import (
+    QuantumCallable,
+    QuantumLambdaFunction,
+)
 from classiq.interface.model.quantum_statement import QuantumStatement
 
-from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
+from classiq.model_expansions.closure import (
+    FunctionClosure,
+    GenerativeClosure,
+    GenerativeFunctionClosure,
+)
 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
-from classiq.qmod.qmod_variable import get_qvar
+from classiq.qmod.qmod_variable import QNum, _create_qvar_for_qtype
 from classiq.qmod.quantum_callable import QCallable
-from classiq.qmod.quantum_expandable import QExpandable, QTerminalCallable
+from classiq.qmod.quantum_expandable import (
+    QExpandable,
+    QLambdaFunction,
+    QTerminalCallable,
+)
 from classiq.qmod.quantum_function import QFunc
 from classiq.qmod.semantics.static_semantics_visitor import resolve_function_calls
+from classiq.qmod.symbolic_expr import SymbolicExpr
 
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreter import Interpreter
 
 
+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)
+        return super().__getitem__(item)
+
+    @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)
-        return get_qvar(quantum_symbol.quantum_type, quantum_symbol.handle)
+        return _create_qvar_for_qtype(
+            quantum_symbol.quantum_type, quantum_symbol.handle
+        )
     if isinstance(param, QuantumOperandDeclaration):
         if param.is_list:
-            func_list: List[FunctionClosure] = evaluated.as_type(list)
-            return [
-                QTerminalCallable(
-                    QuantumFunctionDeclaration(
-                        name=param.name,
-                        positional_arg_declarations=param.positional_arg_declarations,
-                    ),
-                    index_=idx,
-                )
-                for idx, func in enumerate(func_list)
-            ]
+            return QTerminalCallable(
+                QuantumOperandDeclaration(
+                    name=param.name,
+                    positional_arg_declarations=param.positional_arg_declarations,
+                    is_list=True,
+                ),
+            )
         else:
             func = evaluated.as_type(FunctionClosure)
             return QTerminalCallable(
@@ -61,7 +92,7 @@ def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated)
             struct_type=Struct(name=classical_value.struct_declaration.name),
             qmodule=QMODULE,
         )
-    return classical_value
+    return LenList.wrap(classical_value)
 
 
 class _InterpreterExpandable(QFunc):
@@ -70,23 +101,32 @@ class _InterpreterExpandable(QFunc):
         self._interpreter = interpreter
 
     def append_statement_to_body(self, stmt: QuantumStatement) -> None:
-        current_function = self._interpreter._builder.current_function
+        current_operation = self._interpreter._builder._operations[-1]
         dummy_function = NativeFunctionDefinition(
-            name=current_function.name,
-            positional_arg_declarations=current_function.positional_arg_declarations,
+            name=current_operation.name,
+            positional_arg_declarations=current_operation.positional_arg_declarations,
             body=self._interpreter._builder._current_statements + [stmt],
         )
-        resolve_function_calls(
-            dummy_function,
-            nameables_to_dict(self._interpreter._get_function_declarations()),
-        )
+        resolve_function_calls(dummy_function, self._get_function_declarations())
         stmt = dummy_function.body[-1]
-        self._interpreter.emit_statement(stmt)
+        with generative_mode_context(False):
+            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._current_scope.items()
+            if isinstance(evaluated, Evaluated)
+            and isinstance(evaluated.value, FunctionClosure)
+        } | nameables_to_dict(self._interpreter._get_function_declarations())
 
 
 def emit_generative_statements(
     interpreter: "Interpreter",
-    operation: GenerativeFunctionClosure,
+    operation: GenerativeClosure,
     args: List[Evaluated],
 ) -> None:
     python_qmod_args = [
@@ -97,5 +137,83 @@ def emit_generative_statements(
     QExpandable.STACK.append(interpreter_expandable)
     QCallable.CURRENT_EXPANDABLE = interpreter_expandable
     set_frontend_interpreter(interpreter)
-    with interpreter._builder.block_context("body"), generative_mode_context(True):
-        operation.generative_function._py_callable(*python_qmod_args)
+    for block_name, generative_function in operation.generative_blocks.items():
+        with interpreter._builder.block_context(block_name), generative_mode_context(
+            True
+        ):
+            generative_function._py_callable(*python_qmod_args)
+
+
+def emit_operands_as_declarative(
+    interpreter: "Interpreter", param: PositionalArg, arg: Evaluated
+) -> ArgValue:
+    if not isinstance(param, QuantumOperandDeclaration):
+        return arg.emit()
+    value = arg.value
+    if isinstance(value, list):
+        return [
+            _expand_operand_as_declarative(interpreter, param, item) for item in value
+        ]
+    if isinstance(value, GenerativeFunctionClosure):
+        return _expand_operand_as_declarative(interpreter, param, value)
+    if isinstance(value, FunctionClosure):
+        if value.is_lambda:
+            raise ClassiqInternalExpansionError
+        _register_declarative_function(interpreter, value.name)
+        return value.name
+    raise ClassiqInternalExpansionError
+
+
+def _expand_operand_as_declarative(
+    interpreter: "Interpreter",
+    param: QuantumOperandDeclaration,
+    arg: GenerativeFunctionClosure,
+) -> QuantumCallable:
+    if not arg.is_lambda:
+        _register_declarative_function(interpreter, arg.name)
+        return arg.name
+    val = QLambdaFunction(param, arg.generative_blocks["body"]._py_callable)
+    with generative_mode_context(False):
+        val.expand()
+        _DecFuncVisitor(interpreter).visit(val.body)
+    qlambda = QuantumLambdaFunction(
+        pos_rename_params=val.infer_rename_params(),
+        body=val.body,
+    )
+    qlambda.set_op_decl(param)
+    return qlambda
+
+
+def _register_declarative_function(interpreter: "Interpreter", func_name: str) -> None:
+    if func_name in nameables_to_dict(interpreter._expanded_functions):
+        return
+
+    for user_gen_func in interpreter._generative_functions:
+        if user_gen_func.func_decl.name == func_name:
+            break
+    else:
+        return
+
+    with generative_mode_context(False):
+        dec_func = QFunc(user_gen_func._py_callable)
+        dec_func.expand()
+        dec_func_def = QMODULE.native_defs[func_name]
+        interpreter._expanded_functions.append(dec_func_def)
+        _DecFuncVisitor(interpreter).visit(dec_func_def)
+
+
+class _DecFuncVisitor(Visitor):
+    def __init__(self, interpreter: "Interpreter"):
+        self._interpreter = interpreter
+
+    def visit_QuantumFunctionCall(self, call: QuantumFunctionCall) -> None:
+        _register_declarative_function(self._interpreter, call.func_name)
+        for arg in call.positional_args:
+            if isinstance(arg, str):
+                arg = [arg]
+            if isinstance(arg, list):
+                for possible_func_name in arg:
+                    if isinstance(possible_func_name, str):
+                        _register_declarative_function(
+                            self._interpreter, possible_func_name
+                        )

classiq/model_expansions/interpreter.py

@@ -49,6 +49,7 @@ from classiq.model_expansions.capturing.propagated_var_stack import PropagatedVa
 from classiq.model_expansions.closure import (
     Closure,
     FunctionClosure,
+    GenerativeClosure,
     GenerativeFunctionClosure,
 )
 from classiq.model_expansions.debug_flag import debug_mode
@@ -84,7 +85,6 @@ from classiq.model_expansions.scope_initialization import (
 )
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
 from classiq.qmod.builtins.functions import permute
-from classiq.qmod.generative import is_generative_mode
 from classiq.qmod.quantum_function import GenerativeQFunc
 from classiq.qmod.semantics.error_manager import ErrorManager
 
@@ -97,8 +97,12 @@ STATEMENT_TYPES_FOR_SOURCE_REFERENCE_PROPAGATION: Tuple[Type[QuantumStatement],
 
 class Interpreter:
     def __init__(
-        self, model: Model, generative_functions: Optional[List[GenerativeQFunc]] = None
+        self,
+        model: Model,
+        generative_functions: Optional[List[GenerativeQFunc]] = None,
+        is_frontend: bool = False,
     ) -> None:
+        self._is_frontend = is_frontend
         self._model = model
         self._current_scope = Scope()
         self._builder = OperationBuilder()
@@ -202,10 +206,12 @@ class Interpreter:
 
         closure_class: Type[FunctionClosure]
         extra_args: dict[str, Any]
-        if is_generative_mode():
+        if function.is_generative():
             closure_class = GenerativeFunctionClosure
             extra_args = {
-                "generative_function": GenerativeQFunc(function.py_callable, func_decl)
+                "generative_blocks": {
+                    "body": GenerativeQFunc(function.py_callable, func_decl),
+                }
             }
         else:
             closure_class = FunctionClosure
@@ -337,7 +343,7 @@ class Interpreter:
                 # special expansion since permute is generative
                 with self._scope_guard(operation.scope):
                     self._expand_permute()
-            elif isinstance(operation, GenerativeFunctionClosure):
+            elif isinstance(operation, GenerativeClosure):
                 with self._scope_guard(operation.scope):
                     args = [
                         self.evaluate(param.name)

classiq/model_expansions/quantum_operations/classicalif.py

@@ -1,15 +1,15 @@
-from typing import List
+from typing import Sequence
 
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
-from classiq.interface.model.statement_block import ConcreteQuantumStatement
+from classiq.interface.model.quantum_statement import QuantumStatement
 
 from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import Scope
 
 
-def _is_all_identity_calls(body: List[ConcreteQuantumStatement]) -> bool:
+def _is_all_identity_calls(body: Sequence[QuantumStatement]) -> bool:
     return all(
         isinstance(stmt, QuantumFunctionCall) and stmt.func_name.lower() == "identity"
         for stmt in body
@@ -18,22 +18,39 @@ def _is_all_identity_calls(body: List[ConcreteQuantumStatement]) -> bool:
 
 class ClassicalIfEmitter(Emitter[ClassicalIf]):
     def emit(self, classical_if: ClassicalIf, /) -> None:
+        with self._propagated_var_stack.capture_variables(classical_if):
+            self._emit_propagated(classical_if)
+
+    def _emit_propagated(self, classical_if: ClassicalIf) -> None:
         condition = self._interpreter.evaluate(classical_if.condition).as_type(bool)
-        body: List[ConcreteQuantumStatement] = (
-            classical_if.then if condition else classical_if.else_
-        )
+        op_name = "then" if condition else "else"
+        is_generative = classical_if.is_generative()
+
+        body: Sequence[QuantumStatement]
+        if is_generative:
+            if not classical_if.has_generative_block(op_name):
+                return
+            context = self._register_generative_context(classical_if, op_name, op_name)
+            context.blocks["body"] = context.blocks[op_name]
+            context.blocks.pop(op_name)
+            body = context.statements("body")
+        else:
+            body = classical_if.then if condition else classical_if.else_
+
         if _is_all_identity_calls(body):
             return
 
         if not self._should_wrap(body):
             for stmt in body:
-                self._interpreter.emit_statement(stmt)
+                if is_generative:
+                    self._interpreter._builder.emit_statement(stmt)
+                else:
+                    self._interpreter.emit_statement(stmt)
             return
 
         then_else_func = FunctionClosure.create(
-            name="then" if condition else "else",
+            name=op_name,
             body=body,
             scope=Scope(parent=self._current_scope),
         )
-        with self._propagated_var_stack.capture_variables(classical_if):
-            self._emit_quantum_function_call(then_else_func, list())
+        self._emit_quantum_function_call(then_else_func, list())

classiq/model_expansions/quantum_operations/control.py

@@ -21,6 +21,7 @@ from classiq.interface.model.control import Control
 from classiq.interface.model.handle_binding import HANDLE_ID_SEPARATOR, HandleBinding
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
+    ArithmeticOperationKind,
 )
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_type import QuantumBit, QuantumBitvector
@@ -69,6 +70,14 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
     def _emit_canonical_control(self, control: Control) -> None:
         # canonical means control(q, body) where q is a single quantum variable
         control = self._evaluate_types_in_expression(control, control.expression)
+        with self._propagated_var_stack.capture_variables(control):
+            self._emit_propagated(control)
+
+    def _emit_propagated(self, control: Control) -> None:
+        if control.is_generative():
+            context = self._register_generative_context(control, CONTROL_OPERATOR_NAME)
+            control = control.copy(update={"body": context.statements("body")})
+
         if self._should_wrap_control(control):
             self._emit_wrapped(control)
             return
@@ -90,26 +99,24 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
             blocks=dict(body=control.body),
             scope=Scope(parent=self._current_scope),
         )
-        with self._propagated_var_stack.capture_variables(control):
-            context = self._expand_operation(control_operation)
-            validate_args_are_not_propagated(
-                control.var_handles,
-                self._propagated_var_stack.get_propagated_variables(),
-            )
+        context = self._expand_operation(control_operation)
+        validate_args_are_not_propagated(
+            control.var_handles,
+            self._propagated_var_stack.get_propagated_variables(),
+        )
         self._update_control_state(control)
         self._builder.emit_statement(
             control.copy(update=dict(body=context.statements("body")))
         )
 
     def _emit_wrapped(self, control: Control) -> None:
-        with self._propagated_var_stack.capture_variables(control):
-            wrapping_function = self._create_expanded_wrapping_function(
-                CONTROL_OPERATOR_NAME, control.body
-            )
-            validate_args_are_not_propagated(
-                control.var_handles,
-                self._propagated_var_stack.get_propagated_variables(),
-            )
+        wrapping_function = self._create_expanded_wrapping_function(
+            CONTROL_OPERATOR_NAME, control.body
+        )
+        validate_args_are_not_propagated(
+            control.var_handles,
+            self._propagated_var_stack.get_propagated_variables(),
+        )
         self._update_control_state(control)
         self._builder.emit_statement(
             control.copy(update=dict(body=[wrapping_function]))
@@ -208,7 +215,7 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
         arith_expression = ArithmeticOperation(
             result_var=HandleBinding(name=aux_var),
             expression=control.expression,
-            inplace_result=False,
+            operation_kind=ArithmeticOperationKind.Assignment,
         )
         self._interpreter.emit_statement(
             WithinApply(

classiq/model_expansions/quantum_operations/emitter.py

@@ -1,5 +1,15 @@
 from abc import abstractmethod
-from typing import TYPE_CHECKING, Generic, List, Sequence, TypeVar, cast
+from typing import (
+    TYPE_CHECKING,
+    Dict,
+    Generic,
+    List,
+    Optional,
+    Sequence,
+    TypeVar,
+    Union,
+    cast,
+)
 
 from classiq.interface.debug_info.debug_info import FunctionDebugInfo
 from classiq.interface.ide.visual_model import OperationLevel
@@ -14,7 +24,7 @@ from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
 )
-from classiq.interface.model.quantum_statement import QuantumStatement
+from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
@@ -23,7 +33,7 @@ from classiq.model_expansions.capturing.propagated_var_stack import (
     PropagatedVarStack,
     validate_args_are_not_propagated,
 )
-from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.closure import Closure, FunctionClosure, GenerativeClosure
 from classiq.model_expansions.evaluators.argument_types import (
     add_information_from_output_arguments,
 )
@@ -33,10 +43,13 @@ from classiq.model_expansions.evaluators.parameter_types import (
 from classiq.model_expansions.function_builder import (
     FunctionContext,
     OperationBuilder,
+    OperationContext,
 )
+from classiq.model_expansions.generative_functions import emit_operands_as_declarative
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
 from classiq.qmod.builtins.functions import allocate, free
+from classiq.qmod.quantum_function import GenerativeQFunc
 
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreter import Interpreter
@@ -50,13 +63,24 @@ class Emitter(Generic[QuantumStatementT]):
         self._interpreter = interpreter
 
         self._scope_guard = self._interpreter._scope_guard
-        self._expand_operation = self._interpreter._expand_operation
         self._machine_precision = self._interpreter._model.preferences.machine_precision
 
+        self._generative_contexts: Dict[str, OperationContext] = {}
+
     @abstractmethod
     def emit(self, statement: QuantumStatementT, /) -> None:
         pass
 
+    def _expand_operation(self, closure: Closure) -> OperationContext:
+        if closure.name in self._generative_contexts:
+            if isinstance(closure, FunctionClosure):
+                return FunctionContext(
+                    closure=closure,
+                    blocks=self._generative_contexts[closure.name].blocks,
+                )
+            return self._generative_contexts[closure.name]
+        return self._interpreter._expand_operation(closure)
+
     @property
     def _propagated_var_stack(self) -> PropagatedVarStack:
         return self._interpreter._propagated_var_stack
@@ -181,7 +205,10 @@ class Emitter(Generic[QuantumStatementT]):
             new_positional_arg_decls, evaluated_args
         )
         if is_atomic:
-            return [arg.emit() for arg in evaluated_args]
+            return [
+                emit_operands_as_declarative(self._interpreter, param, arg)
+                for param, arg in zip(new_positional_arg_decls, evaluated_args)
+            ]
 
         positional_args = [
             arg.emit() for arg in evaluated_args if isinstance(arg.value, QuantumSymbol)
@@ -219,3 +246,31 @@ class Emitter(Generic[QuantumStatementT]):
                     evaluated_args,
                 ),
             )
+
+    def _register_generative_context(
+        self,
+        op: QuantumOperation,
+        context_name: str,
+        block_names: Union[None, str, List[str]] = None,
+        func_decl: Optional[NamedParamsQuantumFunctionDeclaration] = None,
+    ) -> OperationContext:
+        if isinstance(block_names, str):
+            block_names = [block_names]
+        block_names = block_names or ["body"]
+        func_decl = func_decl or NamedParamsQuantumFunctionDeclaration(
+            name=context_name
+        )
+        gen_closure = GenerativeClosure(
+            name=func_decl.name,
+            scope=Scope(parent=self._interpreter._current_scope),
+            blocks={},
+            generative_blocks={
+                block_name: GenerativeQFunc(
+                    op.get_generative_block(block_name), func_decl
+                )
+                for block_name in block_names
+            },
+        )
+        context = self._interpreter._expand_operation(gen_closure)
+        self._generative_contexts[context_name] = context
+        return context

classiq/model_expansions/quantum_operations/expression_operation.py

@@ -58,17 +58,20 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
         symbols_parts, bind_ops = self._get_bind_ops(symbols_to_split)
 
         for symbol_parts in symbols_parts:
-            for symbol in symbol_parts:
+            for symbol, symbol_part_var_name in symbol_parts:
                 if symbol.handle.identifier not in self._current_scope:
                     self._interpreter.emit_statement(
                         VariableDeclarationStatement(
-                            name=symbol.handle.identifier,
+                            name=symbol_part_var_name,
                             quantum_type=symbol.quantum_type,
                         )
                     )
 
         new_expression = self._update_op_expression(
-            {symbol.handle: symbol for symbol in chain.from_iterable(symbols_parts)},
+            {
+                symbol.handle: symbol_part_var_name
+                for symbol, symbol_part_var_name in chain.from_iterable(symbols_parts)
+            },
             expression,
         )
         new_op = op.copy(update=dict(expression=new_expression))
@@ -83,7 +86,7 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
 
     def _update_op_expression(
         self,
-        symbol_parts: Dict[HandleBinding, QuantumSymbol],
+        symbol_parts: Dict[HandleBinding, str],
         expression: Expression,
     ) -> Expression:
         vrc = VarRefCollector(ignore_duplicated_handles=True)
@@ -94,7 +97,7 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
             collapsed_handle = handle.collapse()
             if collapsed_handle in symbol_parts:
                 new_expr_str = new_expr_str.replace(
-                    str(handle), symbol_parts[collapsed_handle].handle.identifier
+                    str(handle), symbol_parts[collapsed_handle]
                 )
         self._check_all_handles_were_replaced(new_expr_str)
 
@@ -115,32 +118,38 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
             ):
                 raise ClassiqInternalExpansionError(f"Did not replace handle {handle}")
 
-    @staticmethod
     def _get_bind_ops(
+        self,
         symbols_to_split: List[QuantumSymbol],
-    ) -> Tuple[List[List[QuantumSymbol]], List[BindOperation]]:
+    ) -> Tuple[List[List[Tuple[QuantumSymbol, str]]], List[BindOperation]]:
         bind_ops = []
         symbols_parts = []
         for symbol in symbols_to_split:
-            symbol_parts = ExpressionOperationEmitter._get_symbol_parts(symbol)
+            symbol_parts = self._get_symbol_parts(symbol)
             symbols_parts.append(symbol_parts)
             bind_ops.append(
                 BindOperation(
                     in_handles=[symbol.handle],
                     out_handles=[
-                        HandleBinding(name=symbol_part.handle.identifier)
-                        for symbol_part in symbol_parts
+                        HandleBinding(name=symbol_part_var_name)
+                        for _, symbol_part_var_name in symbol_parts
                     ],
                 )
             )
         return symbols_parts, bind_ops
 
-    @staticmethod
-    def _get_symbol_parts(symbol: QuantumSymbol) -> List[QuantumSymbol]:
+    def _get_symbol_parts(
+        self, symbol: QuantumSymbol
+    ) -> List[Tuple[QuantumSymbol, str]]:
         quantum_type = symbol.quantum_type
 
         if isinstance(quantum_type, (QuantumBit, QuantumNumeric)):
-            return [symbol]
+            return [
+                (
+                    symbol,
+                    self._counted_name_allocator.allocate(symbol.handle.identifier),
+                )
+            ]
 
         if isinstance(quantum_type, QuantumBitvector):
             if not quantum_type.has_length:
@@ -150,7 +159,7 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
                 )
             return list(
                 chain.from_iterable(
-                    ExpressionOperationEmitter._get_symbol_parts(symbol[idx])
+                    self._get_symbol_parts(symbol[idx])
                     for idx in range(quantum_type.length_value)
                 )
             )
@@ -160,7 +169,7 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
 
         return list(
             chain.from_iterable(
-                ExpressionOperationEmitter._get_symbol_parts(field_symbol)
+                self._get_symbol_parts(field_symbol)
                 for field_symbol in symbol.fields.values()
             )
         )
@@ -204,7 +213,7 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
         op_with_evaluated_types = op.copy(update={"expression": expression})
         vrc = VarRefCollector()
         vrc.visit(ast.parse(op_with_evaluated_types.expression.expr))
-        handles = list(vrc.var_handles)
+        handles = vrc.var_handles
         op_with_evaluated_types.set_var_handles(handles)
         op_with_evaluated_types.initialize_var_types(
             {