classiq 0.76.0__py3-none-any.whl → 0.78.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/function_calls_cache.py

@@ -0,0 +1,84 @@
+import json
+from typing import Any
+
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_struct_proxy import (
+    ClassicalStructProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.utils import (
+    get_proxy_type,
+)
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+)
+
+from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.scope import (
+    Evaluated,
+    QuantumSymbol,
+    evaluated_to_str as evaluated_classical_param_to_str,
+)
+
+
+def get_func_call_cache_key(
+    decl: NamedParamsQuantumFunctionDeclaration,
+    args: list[Evaluated],
+) -> str:
+    if len(decl.positional_arg_declarations) != len(args):
+        raise ClassiqInternalExpansionError(
+            "Mismatch between number of args to number of arg declarations"
+        )
+
+    # output arguments cannot affect the morphization of the function, as their
+    # attributes are defined locally by the function, according to other arguments
+    non_outputs_args = [
+        arg
+        for arg_decl, arg in zip(decl.positional_arg_declarations, args)
+        if not (
+            isinstance(arg_decl, PortDeclaration)
+            and arg_decl.direction is PortDeclarationDirection.Output
+        )
+    ]
+    return f"{decl.name}__{_evaluated_args_to_str(non_outputs_args)}"
+
+
+def _evaluated_args_to_str(evaluated_args: list[Evaluated]) -> str:
+    args_signature = [
+        _evaluated_arg_to_str(eval_arg.value) for eval_arg in evaluated_args
+    ]
+    return json.dumps(args_signature)
+
+
+def _evaluated_arg_to_str(arg: Any) -> str:
+    if isinstance(arg, str):
+        return arg
+    if isinstance(arg, QuantumSymbol):
+        return _evaluated_quantum_symbol_to_str(arg)
+    if isinstance(arg, FunctionClosure):
+        return _evaluated_one_operand_to_str(arg)
+    if isinstance(arg, list) and arg and isinstance(arg[0], FunctionClosure):
+        return _evaluated_operands_list_to_str(arg)
+    if isinstance(arg, ClassicalProxy):
+        if isinstance(arg, ClassicalStructProxy):
+            return repr(arg.struct_declaration)
+        return repr(get_proxy_type(arg))
+    return evaluated_classical_param_to_str(arg)
+
+
+def _evaluated_quantum_symbol_to_str(port: QuantumSymbol) -> str:
+    return port.quantum_type.model_dump_json(exclude_none=True, exclude={"name"})
+
+
+def _evaluated_one_operand_to_str(operand: FunctionClosure) -> str:
+    return operand.name
+
+
+def _evaluated_operands_list_to_str(arg: list[FunctionClosure]) -> str:
+    return json.dumps([_evaluated_one_operand_to_str(ope) for ope in arg])

classiq/model_expansions/scope.py

@@ -3,7 +3,9 @@ from collections import UserDict
 from collections.abc import Iterator
 from dataclasses import dataclass
 from functools import singledispatch
-from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
+from typing import TYPE_CHECKING, Any, NoReturn, Optional, TypeVar, Union
+
+import sympy
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -22,7 +24,9 @@ from classiq.interface.generator.expressions.proxies.classical.qmod_struct_insta
 from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
+    GeneralHandle,
     HandleBinding,
+    HandlesList,
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
@@ -32,6 +36,8 @@ from classiq.interface.model.quantum_type import (
     QuantumType,
 )
 
+from classiq.model_expansions.utils.text_utils import readable_list, s
+
 if TYPE_CHECKING:
     from classiq.model_expansions.closure import FunctionClosure
 
@@ -39,10 +45,17 @@ T = TypeVar("T")
 
 
 @dataclass(frozen=True)
-class QuantumSymbol:
-    handle: HandleBinding
+class QuantumVariable:
     quantum_type: QuantumType
 
+    def emit(self) -> GeneralHandle:
+        raise NotImplementedError
+
+
+@dataclass(frozen=True)
+class QuantumSymbol(QuantumVariable):
+    handle: HandleBinding
+
     @property
     def is_subscript(self) -> bool:
         return isinstance(self.handle, (SubscriptHandleBinding, SlicedHandleBinding))
@@ -140,6 +153,47 @@ class QuantumSymbol:
             for field_name, field_type in quantum_type.fields.items()
         }
 
+    def __str__(self) -> str:
+        return str(self.handle)
+
+
+@dataclass(frozen=True)
+class QuantumSymbolList(QuantumVariable):
+    handles: list[HandleBinding]
+
+    @staticmethod
+    def from_symbols(
+        symbols: list[Union[QuantumSymbol, "QuantumSymbolList"]],
+    ) -> "QuantumSymbolList":
+        handles = list(
+            itertools.chain.from_iterable(
+                (
+                    symbol.handles
+                    if isinstance(symbol, QuantumSymbolList)
+                    else [symbol.handle]
+                )
+                for symbol in symbols
+            )
+        )
+        if len(handles) == 0:
+            raise ClassiqExpansionError("Empty concatenation expression")
+        length: Optional[Expression]
+        if any(not symbol.quantum_type.has_size_in_bits for symbol in symbols):
+            length = None
+        else:
+            length = Expression(
+                expr=str(sum(symbol.quantum_type.size_in_bits for symbol in symbols))
+            )
+        return QuantumSymbolList(
+            handles=handles, quantum_type=QuantumBitvector(length=length)
+        )
+
+    def emit(self) -> HandlesList:
+        return HandlesList(handles=self.handles)
+
+    def __str__(self) -> str:
+        return str(self.handles)
+
 
 @singledispatch
 def evaluated_to_str(value: Any) -> str:
@@ -156,34 +210,40 @@ def _evaluated_to_str_struct_literal(value: QmodStructInstance) -> str:
     return f"struct_literal({value.struct_declaration.name}, {', '.join(f'{k}={evaluated_to_str(v)}' for k, v in value.fields.items())})"
 
 
+def _raise_type_error(val: Any, t: type, location_hint: Optional[str]) -> NoReturn:
+    if isinstance(val, sympy.Basic) and len(val.free_symbols) > 0:
+        symbolic_vars = list(val.free_symbols)
+        suffix = f" {location_hint}" if location_hint is not None else ""
+        raise ClassiqExpansionError(
+            f"Cannot use execution parameter{s(symbolic_vars)} {readable_list(symbolic_vars, quote=True)} in a compile-time context{suffix}"
+        )
+    raise ClassiqExpansionError(f"Invalid access to expression {val!r} as {t}")
+
+
 @dataclass(frozen=True)
 class Evaluated:  # FIXME: Merge with EvaluatedExpression if possible
     value: Any
     defining_function: Optional["FunctionClosure"] = None
 
-    def as_type(self, t: type[T]) -> T:
+    def as_type(self, t: type[T], location_hint: Optional[str] = None) -> T:
         if t is int:
-            return self._as_int()  # type: ignore[return-value]
+            return self._as_int(location_hint)  # type: ignore[return-value]
 
         if not isinstance(self.value, t):
-            raise ClassiqExpansionError(
-                f"Invalid access to expression {self.value!r} as {t}"
-            )
+            _raise_type_error(self.value, t, location_hint)
 
         return self.value
 
-    def _as_int(self) -> int:
+    def _as_int(self, location_hint: Optional[str]) -> int:
         if not isinstance(self.value, (int, float)):
-            raise ClassiqExpansionError(
-                f"Invalid access to expression {self.value!r} as {int}"
-            )
+            _raise_type_error(self.value, int, location_hint)
 
         return int(self.value)
 
     def emit(self) -> ArgValue:
         from classiq.model_expansions.closure import FunctionClosure
 
-        if isinstance(self.value, (QuantumSymbol, FunctionClosure)):
+        if isinstance(self.value, (QuantumVariable, FunctionClosure)):
             return self.value.emit()
         if isinstance(self.value, list) and all(
             isinstance(item, FunctionClosure) for item in self.value

classiq/model_expansions/transformers/model_renamer.py

@@ -33,7 +33,7 @@ def _handle_contains_handle(handle: HandleBinding, other_handle: HandleBinding)
     return 0
 
 
-class _ExprNormalizer(ast.NodeTransformer):
+class ExprNormalizer(ast.NodeTransformer):
     def visit_Call(self, node: ast.Call) -> ast.AST:
         if not isinstance(node.func, ast.Name):
             return self.generic_visit(node)
@@ -74,7 +74,7 @@ SymbolRenaming = Mapping[HandleBinding, Sequence[HandleRenaming]]
 def _rewrite_expression(
     symbol_mapping: SymbolRenaming, expression: Expression
 ) -> Expression:
-    normalized_expr = _ExprNormalizer().visit(ast.parse(expression.expr))
+    normalized_expr = ExprNormalizer().visit(ast.parse(expression.expr))
     vrc = VarRefCollector(
         ignore_duplicated_handles=True, ignore_sympy_symbols=True, unevaluated=True
     )

classiq/model_expansions/transformers/type_qualifier_inference.py

@@ -0,0 +1,183 @@
+import ast
+import functools
+import itertools
+from collections.abc import Collection, Iterator, Sequence
+from contextlib import contextmanager
+
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
+from classiq.interface.model.allocate import Allocate
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.control import Control
+from classiq.interface.model.invert import Invert
+from classiq.interface.model.model_visitor import ModelVisitor
+from classiq.interface.model.phase_operation import PhaseOperation
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.power import Power
+from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
+    AmplitudeLoadingOperation,
+)
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
+)
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumExpressionOperation,
+)
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_statement import QuantumStatement
+from classiq.interface.model.within_apply_operation import WithinApply
+
+from classiq.model_expansions.visitors.variable_references import VarRefCollector
+
+
+class TypeQualifierInference(ModelVisitor):
+    """
+    This class assumes that function calls are topologically sorted, so it traverses
+    the list of function calls and infers the type qualifiers for each function call
+    without going recursively into the function calls.
+    The function definition ports are modified inplace.
+    """
+
+    def __init__(self, support_unused_ports: bool = True) -> None:
+        self._signature_ports: dict[str, PortDeclaration] = dict()
+        self._inferred_ports: dict[str, PortDeclaration] = dict()
+        self._support_unused_ports = (
+            support_unused_ports  # could be turned off for debugging
+        )
+
+    @contextmanager
+    def infer_ports(self, ports: Collection[PortDeclaration]) -> Iterator[bool]:
+        for port in ports:
+            if port.type_qualifier is TypeQualifier.Inferred:
+                self._inferred_ports[port.name] = port
+            else:
+                self._signature_ports[port.name] = port
+
+        yield len(self._inferred_ports) > 0
+
+        self._set_unused_as_const()
+        self._signature_ports.clear()
+        self._inferred_ports.clear()
+
+    def _set_unused_as_const(self) -> None:
+        unresolved_ports = [
+            port
+            for port in self._inferred_ports.values()
+            if port.type_qualifier is TypeQualifier.Inferred
+        ]
+        if not self._support_unused_ports and len(unresolved_ports) > 0:
+            raise ClassiqInternalExpansionError(
+                f"Unresolved inferred ports detected: {', '.join(port.name for port in unresolved_ports)}. "
+                "All ports must have their type qualifiers resolved."
+            )
+        for port in unresolved_ports:
+            port.type_qualifier = TypeQualifier.Const
+
+    def _reduce_qualifier(self, candidate: str, qualifier: TypeQualifier) -> None:
+        if candidate in self._inferred_ports:
+            self._inferred_ports[candidate].type_qualifier = TypeQualifier.and_(
+                self._inferred_ports[candidate].type_qualifier, qualifier
+            )
+
+    def run(
+        self, ports: Collection[PortDeclaration], body: Sequence[QuantumStatement]
+    ) -> None:
+        with self.infer_ports(ports) as should_infer:
+            if should_infer:
+                self.visit(body)
+
+    def visit_QuantumFunctionCall(self, call: QuantumFunctionCall) -> None:
+        for handle, port in call.handles_with_params:
+            self._reduce_qualifier(handle.name, port.type_qualifier)
+
+    def visit_Allocate(self, alloc: Allocate) -> None:
+        self._reduce_qualifier(alloc.target.name, TypeQualifier.QFree)
+
+    def visit_BindOperation(self, bind_op: BindOperation) -> None:
+        reduced_qualifier = self._get_reduced_qualifier(bind_op)
+        for handle in itertools.chain(bind_op.in_handles, bind_op.out_handles):
+            self._reduce_qualifier(handle.name, reduced_qualifier)
+
+    def _get_reduced_qualifier(self, bind_op: BindOperation) -> TypeQualifier:
+        handles = itertools.chain(bind_op.in_handles, bind_op.out_handles)
+        op_vars = {handle.name for handle in handles}
+
+        signature_ports = {
+            name: self._signature_ports[name]
+            for name in op_vars.intersection(self._signature_ports)
+        }
+        known_inferred_ports = {
+            name: self._inferred_ports[name]
+            for name in op_vars.intersection(self._inferred_ports)
+            if self._inferred_ports[name].type_qualifier is not TypeQualifier.Inferred
+        }
+        min_qualifier = self._get_min_qualifier(known_inferred_ports, signature_ports)
+        if not all(
+            port.type_qualifier is min_qualifier for port in signature_ports.values()
+        ):
+            raise ClassiqInternalExpansionError(
+                f"Bind operation {bind_op} has inconsistent type qualifiers: "
+                f"{signature_ports}, {known_inferred_ports}"
+            )
+
+        return min_qualifier
+
+    @staticmethod
+    def _get_min_qualifier(
+        known_inferred_ports: dict[str, PortDeclaration],
+        signature_ports: dict[str, PortDeclaration],
+    ) -> TypeQualifier:
+        known_ports = tuple(
+            itertools.chain(signature_ports.values(), known_inferred_ports.values())
+        )
+        if len(known_ports) == 0:
+            return TypeQualifier.Quantum
+        elif len(known_ports) == 1:
+            return known_ports[0].type_qualifier
+        else:
+            return functools.reduce(
+                TypeQualifier.and_, (port.type_qualifier for port in known_ports)
+            )
+
+    @staticmethod
+    def _extract_expr_vars(expr_op: QuantumExpressionOperation) -> list[str]:
+        vrc = VarRefCollector(
+            ignore_duplicated_handles=True, ignore_sympy_symbols=True, unevaluated=True
+        )
+        vrc.visit(ast.parse(expr_op.expression.expr))
+        return [handle.name for handle in vrc.var_handles]
+
+    def visit_ArithmeticOperation(self, arith: ArithmeticOperation) -> None:
+        result_var = arith.result_var.name
+        self._reduce_qualifier(result_var, TypeQualifier.QFree)
+        for expr_var in self._extract_expr_vars(arith):
+            self._reduce_qualifier(expr_var, TypeQualifier.Const)
+
+    def visit_AmplitudeLoadingOperation(
+        self, amp_load: AmplitudeLoadingOperation
+    ) -> None:
+        result_var = amp_load.result_var.name
+        self._reduce_qualifier(result_var, TypeQualifier.Quantum)
+        for expr_var in self._extract_expr_vars(amp_load):
+            self._reduce_qualifier(expr_var, TypeQualifier.Const)
+
+    def visit_PhaseOperation(self, phase_op: PhaseOperation) -> None:
+        for expr_var in self._extract_expr_vars(phase_op):
+            self._reduce_qualifier(expr_var, TypeQualifier.Const)
+
+    def visit_Control(self, control: Control) -> None:
+        for control_var in self._extract_expr_vars(control):
+            self._reduce_qualifier(control_var, TypeQualifier.Const)
+        self.visit(control.body)
+        if control.else_block is not None:
+            self.visit(control.else_block)
+
+    def visit_Invert(self, invert: Invert) -> None:
+        self.visit(invert.body)
+
+    def visit_Power(self, power: Power) -> None:
+        self.visit(power.body)
+
+    def visit_WithinApply(self, within_apply: WithinApply) -> None:
+        self.visit(within_apply.compute)
+        self.visit(within_apply.action)

classiq/model_expansions/utils/text_utils.py

@@ -10,7 +10,9 @@ def they(items: list) -> str:
     return "it" if len(items) == 1 else "they"
 
 
-def readable_list(items: list) -> str:
+def readable_list(items: list, quote: bool = False) -> str:
+    if quote:
+        items = [repr(str(item)) for item in items]
     if len(items) == 1:
         return str(items[0])
-    return f"{', '.join(items[:-1])} and {items[-1]}"
+    return f"{', '.join(items[:-1])}{',' if len(items) > 2 else ''} and {items[-1]}"

classiq/model_expansions/visitors/symbolic_param_inference.py

@@ -62,9 +62,9 @@ class SymbolicParamInference(ModelVisitor):
     def __init__(
         self,
         functions: list[NativeFunctionDefinition],
-        additional_signatures: (
-            list[NamedParamsQuantumFunctionDeclaration] | None
-        ) = None,
+        additional_signatures: Optional[
+            list[NamedParamsQuantumFunctionDeclaration]
+        ] = None,
     ) -> None:
         self._functions = nameables_to_dict(functions)
         self._additional_signatures = (
@@ -73,7 +73,6 @@ class SymbolicParamInference(ModelVisitor):
             else nameables_to_dict(additional_signatures)
         )
         self._inferred_funcs: set[str] = set()
-        self._call_stack: list[str] = []
         self._scope: Mapping[str, ClassicalType] = {}
         self._scope_operands: dict[str, QuantumOperandDeclaration] = {}
 
@@ -81,9 +80,6 @@ class SymbolicParamInference(ModelVisitor):
         for func in self._functions.values():
             self._infer_func_params(func)
 
-    def _is_recursive_call(self, func: str) -> bool:
-        return func in self._call_stack
-
     @contextmanager
     def function_context(
         self,
@@ -91,8 +87,6 @@ class SymbolicParamInference(ModelVisitor):
         scope: Mapping[str, ClassicalType],
         scope_operands: dict[str, QuantumOperandDeclaration],
     ) -> Iterator[None]:
-        if func_name is not None:
-            self._call_stack.append(func_name)
         prev_scope = self._scope
         self._scope = scope
         prev_scope_ops = self._scope_operands
@@ -100,12 +94,11 @@ class SymbolicParamInference(ModelVisitor):
         yield
         self._scope = prev_scope
         self._scope_operands = prev_scope_ops
-        if func_name is not None:
-            self._call_stack.pop()
 
     def _infer_func_params(self, func: NativeFunctionDefinition) -> None:
         if func.name in self._inferred_funcs:
             return
+        self._inferred_funcs.add(func.name)
         scope = {param.name: param.classical_type for param in func.param_decls}
         scope_operands = func.operand_declarations_dict
         with self.function_context(func.name, scope, scope_operands):
@@ -114,7 +107,6 @@ class SymbolicParamInference(ModelVisitor):
                     self._process_compile_time_expression(expr.expr)
             self._set_enums_generative(func)
             self.visit(func.body)
-        self._inferred_funcs.add(func.name)
 
     def _set_enums_generative(self, decl: AnonQuantumFunctionDeclaration) -> None:
         for param in decl.positional_arg_declarations:
@@ -144,9 +136,6 @@ class SymbolicParamInference(ModelVisitor):
 
     def visit_QuantumFunctionCall(self, call: QuantumFunctionCall) -> None:
         self._process_compile_time_expressions(call.function)
-        name = call.func_name
-        if self._is_recursive_call(name):
-            return  # Recursion is not fully supported
         params = self._get_params(call)
         for param, arg in zip_longest(params, call.positional_args):
             if (

classiq/open_library/functions/lookup_table.py

@@ -39,7 +39,7 @@ def span_lookup_table(func: RealFunction, *targets: QNum) -> QNum:
         The quantum result of applying func to targets
 
     Notes:
-        Must be called inside a generative function (`@qfunc(generative=True)`)
+        Must be called inside a generative function (`@qfunc`)
     """
     if len(targets) == 0:
         raise ClassiqValueError("No targets specified")

classiq/open_library/functions/state_preparation.py

@@ -334,7 +334,7 @@ def _classical_hadamard_transform(arr: list[float]) -> np.ndarray:
     return 1 / np.sqrt(len(arr)) * np.array(sympy.fwht(np.array(arr)))
 
 
-@qfunc(generative=True)
+@qfunc
 def _load_phases(
     phases: list[float],
     target: QArray[QBit, Literal["log(get_field(phases, 'len'), 2)"]],

classiq/qmod/builtins/classical_execution_primitives.py

@@ -1,8 +1,8 @@
 from typing import Final, Optional, Union
 
+from classiq.interface.applications.iqae.iqae_result import IQAEResult
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.execution_preferences import QaeWithQpeEstimationMethod
-from classiq.interface.executor.iqae_result import IQAEResult
 from classiq.interface.executor.result import (
     EstimationResult,
     EstimationResults,

classiq/qmod/create_model_function.py

@@ -1,4 +1,4 @@
-from typing import Optional, Union
+from typing import Optional, Union, cast
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
@@ -7,10 +7,26 @@ from classiq.interface.generator.model.preferences.preferences import Preference
 from classiq.interface.model.model import MAIN_FUNCTION_NAME, SerializedModel
 
 from classiq.qmod.classical_function import CFunc
-from classiq.qmod.quantum_function import GenerativeQFunc, QFunc
+from classiq.qmod.quantum_function import BaseQFunc, GenerativeQFunc, QFunc
 from classiq.qmod.write_qmod import write_qmod
 
 
+class _EntryPointWrapper(str):
+    entry_point: BaseQFunc
+
+
+def add_entry_point(
+    new_model: SerializedModel, old_model: SerializedModel
+) -> SerializedModel:
+    if not hasattr(old_model, "entry_point"):
+        return new_model
+    new_model_with_entry_point = _EntryPointWrapper(new_model)
+    new_model_with_entry_point.entry_point = cast(
+        _EntryPointWrapper, old_model
+    ).entry_point
+    return cast(SerializedModel, new_model_with_entry_point)
+
+
 def create_model(
     entry_point: Union[QFunc, GenerativeQFunc],
     constraints: Optional[Constraints] = None,
@@ -48,7 +64,9 @@ def create_model(
         preferences,
         classical_execution_function,
     )
-    result = model.get_model()
+    serialized_model = _EntryPointWrapper(model.get_model())
+    serialized_model.entry_point = entry_point
+    result = cast(SerializedModel, serialized_model)
 
     if out_file is not None:
         write_qmod(result, out_file)

classiq/qmod/global_declarative_switch.py

@@ -0,0 +1,19 @@
+from collections.abc import Iterator
+from contextlib import contextmanager
+
+_DECLARATIVE_SWITCH = False
+
+
+def get_global_declarative_switch() -> bool:
+    return _DECLARATIVE_SWITCH
+
+
+@contextmanager
+def set_global_declarative_switch() -> Iterator[None]:
+    global _DECLARATIVE_SWITCH
+    previous = _DECLARATIVE_SWITCH
+    _DECLARATIVE_SWITCH = True
+    try:
+        yield
+    finally:
+        _DECLARATIVE_SWITCH = previous

classiq/qmod/native/pretty_printer.py

@@ -35,6 +35,7 @@ from classiq.interface.model.control import Control
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     HandleBinding,
+    HandlesList,
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
@@ -395,6 +396,9 @@ class DSLPrettyPrinter(ModelVisitor):
     def visit_FieldHandleBinding(self, var_ref: FieldHandleBinding) -> str:
         return f"{self.visit(var_ref.base_handle)}.{self.visit(var_ref.field)}"
 
+    def visit_HandlesList(self, handles: HandlesList) -> str:
+        return f"{{{', '.join(map(self.visit, handles.handles))}}}"
+
     def visit_ArithmeticOperation(self, arith_op: ArithmeticOperation) -> str:
         if arith_op.operation_kind == ArithmeticOperationKind.Assignment:
             op = "="

classiq/qmod/pretty_print/pretty_printer.py

@@ -37,6 +37,7 @@ from classiq.interface.model.control import Control
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     HandleBinding,
+    HandlesList,
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
@@ -518,6 +519,9 @@ class PythonPrettyPrinter(ModelVisitor):
     def visit_FieldHandleBinding(self, var_ref: FieldHandleBinding) -> str:
         return f"{self.visit(var_ref.base_handle)}.{self.visit(var_ref.field)}"
 
+    def visit_HandlesList(self, handles: HandlesList) -> str:
+        return self.visit(handles.handles)
+
     def visit_ArithmeticOperation(
         self, arith_op: ArithmeticOperation, in_lambda: bool = False
     ) -> str: