classiq 0.77.0__py3-none-any.whl → 0.79.0__py3-none-any.whl

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

@@ -8,7 +8,12 @@ from classiq.interface.generator.expressions.atomic_expression_functions import
     CLASSICAL_ATTRIBUTES,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.classical_type import ClassicalType
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalArray,
+    ClassicalList,
+    ClassicalTuple,
+    ClassicalType,
+)
 from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.model.classical_parameter_declaration import (
@@ -20,7 +25,6 @@ from classiq.interface.model.native_function_definition import NativeFunctionDef
 from classiq.interface.model.quantum_function_call import ArgValue, QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     AnonPositionalArg,
-    AnonQuantumFunctionDeclaration,
     AnonQuantumOperandDeclaration,
     NamedParamsQuantumFunctionDeclaration,
     QuantumOperandDeclaration,
@@ -33,6 +37,22 @@ from classiq.interface.model.quantum_lambda_function import (
 from classiq.model_expansions.visitors.variable_references import VarRefCollector
 
 
+def set_generative_recursively(classical_type: ClassicalType) -> None:
+    if (
+        isinstance(classical_type, TypeName)
+        and classical_type.has_classical_struct_decl
+    ):
+        for field_type in classical_type.classical_struct_decl.variables.values():
+            set_generative_recursively(field_type)
+        return
+    classical_type.set_generative()
+    if isinstance(classical_type, (ClassicalArray, ClassicalList)):
+        set_generative_recursively(classical_type.element_type)
+    if isinstance(classical_type, ClassicalTuple):
+        for element_type in classical_type.element_types:
+            set_generative_recursively(element_type)
+
+
 def _get_expressions(arg: ArgValue) -> list[Expression]:
     if isinstance(arg, Expression):
         return [arg]
@@ -73,7 +93,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 +100,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 +107,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,31 +114,18 @@ 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):
             for param in func.positional_arg_declarations:
                 for expr in _get_param_expressions(param):
                     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:
-            if (
-                isinstance(param, AnonClassicalParameterDeclaration)
-                and param.name is not None
-                and isinstance(param.classical_type, TypeName)
-                and param.classical_type.is_enum
-            ):
-                self._scope[param.name].set_generative()
 
     def visit_QuantumLambdaFunction(self, func: QuantumLambdaFunction) -> None:
         func.set_op_decl(func.func_decl.model_copy(deep=True))
@@ -139,26 +140,28 @@ class SymbolicParamInference(ModelVisitor):
             )
         )
         with self.function_context(None, scope, scope_operands):
-            self._set_enums_generative(func.named_func_decl)
             self.visit(func.body)
 
     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 (
                 not isinstance(param, AnonClassicalParameterDeclaration)
-                or param.classical_type.is_generative
+                or param.classical_type.is_purely_generative
             ):
                 self._process_compile_time_expressions(arg)
             else:
+                if isinstance(arg, Expression):
+                    for expr_part in self.get_generative_expression_parts(arg.expr):
+                        self._process_compile_time_expression(expr_part)
                 for expr in _get_expressions(arg):
                     self._process_nested_compile_time_expression(expr.expr)
         self.generic_visit(call)
 
+    def get_generative_expression_parts(self, expr: str) -> list[str]:
+        return []
+
     def _get_params(self, call: QuantumFunctionCall) -> Sequence[AnonPositionalArg]:
         name = call.func_name
         if name in self._scope_operands:
@@ -185,7 +188,7 @@ class SymbolicParamInference(ModelVisitor):
                 not isinstance(handle, FieldHandleBinding)
                 or handle.field not in CLASSICAL_ATTRIBUTES
             ):
-                self._scope[handle.name].set_generative()
+                set_generative_recursively(self._scope[handle.name])
 
     def _process_nested_compile_time_expression(self, expr: str) -> None:
         vrc = VarRefCollector(
@@ -195,3 +198,5 @@ class SymbolicParamInference(ModelVisitor):
         for handle in vrc.var_handles:
             for nested_expr in handle.expressions():
                 self._process_compile_time_expression(nested_expr.expr)
+        for handle in vrc.subscript_handles:
+            self._process_compile_time_expression(str(handle))

classiq/model_expansions/visitors/variable_references.py

@@ -34,11 +34,18 @@ class VarRefCollector(ast.NodeVisitor):
         self._ignore_sympy_symbols = ignore_sympy_symbols
         self._unevaluated = unevaluated
         self._is_nested = False
+        self._in_subscript = False
 
     @property
     def var_handles(self) -> list[HandleBinding]:
         return list(self._var_handles)
 
+    @property
+    def subscript_handles(self) -> list[HandleBinding]:
+        return [
+            handle for handle, in_subscript in self._var_handles.items() if in_subscript
+        ]
+
     def visit(self, node: ast.AST) -> Union[
         SubscriptHandleBinding,
         SlicedHandleBinding,
@@ -55,42 +62,8 @@ class VarRefCollector(ast.NodeVisitor):
             )
         return res
 
-    def visit_Subscript(
-        self, node: ast.Subscript
-    ) -> Union[SubscriptHandleBinding, SlicedHandleBinding, None]:
-        self.visit(node.slice)
-        with self.set_nested():
-            base_handle = self.visit(node.value)
-        if base_handle is None:
-            return None
-
-        handle: Union[SubscriptHandleBinding, SlicedHandleBinding]
-        if isinstance(node.slice, ast.Slice):
-            if not self._unevaluated and (
-                not isinstance(node.slice.lower, ast.Num)
-                or not isinstance(node.slice.upper, ast.Num)
-            ):
-                raise ClassiqInternalExpansionError("Unevaluated slice bounds.")
-            if node.slice.lower is None or node.slice.upper is None:
-                raise ClassiqExpansionError(
-                    f"{str(base_handle)!r} slice must specify both lower and upper bounds"
-                )
-            handle = SlicedHandleBinding(
-                base_handle=base_handle,
-                start=Expression(expr=ast.unparse(node.slice.lower)),
-                end=Expression(expr=ast.unparse(node.slice.upper)),
-            )
-        elif not self._unevaluated and not isinstance(node.slice, ast.Num):
-            raise ClassiqInternalExpansionError("Unevaluated slice.")
-        else:
-            handle = SubscriptHandleBinding(
-                base_handle=base_handle,
-                index=Expression(expr=ast.unparse(node.slice)),
-            )
-
-        if not self._is_nested:
-            self._var_handles[handle] = True
-        return handle
+    def visit_Subscript(self, node: ast.Subscript) -> Union[HandleBinding, None]:
+        return self._get_subscript_handle(node.value, node.slice)
 
     def visit_Attribute(self, node: ast.Attribute) -> Optional[FieldHandleBinding]:
         return self._get_field_handle(node.value, node.attr)
@@ -111,7 +84,6 @@ class VarRefCollector(ast.NodeVisitor):
                 raise ClassiqInternalExpansionError(
                     "Unexpected 'do_subscript' arguments"
                 )
-            self.visit(node.args[1])
             return self._get_subscript_handle(node.args[0], node.args[1])
         return self.generic_visit(node)
 
@@ -127,20 +99,27 @@ class VarRefCollector(ast.NodeVisitor):
             field=field,
         )
         if not self._is_nested:
-            self._var_handles[handle] = True
+            self._add_handle(handle)
         return handle
 
     def _get_subscript_handle(
         self, subject: ast.expr, subscript: ast.expr
     ) -> Optional[HandleBinding]:
+        with self.set_in_subscript():
+            self.visit(subscript)
         with self.set_nested():
             base_handle = self.visit(subject)
         if base_handle is None:
             return None
         handle: HandleBinding
         if isinstance(subscript, ast.Slice):
+            if not self._unevaluated and (
+                not isinstance(subscript.lower, ast.Num)
+                or not isinstance(subscript.upper, ast.Num)
+            ):
+                raise ClassiqInternalExpansionError("Unevaluated slice bounds")
             if subscript.lower is None or subscript.upper is None:
-                raise ClassiqExpansionError(
+                raise ClassiqInternalExpansionError(
                     f"{str(base_handle)!r} slice must specify both lower and upper bounds"
                 )
             handle = SlicedHandleBinding(
@@ -148,13 +127,15 @@ class VarRefCollector(ast.NodeVisitor):
                 start=Expression(expr=ast.unparse(subscript.lower)),
                 end=Expression(expr=ast.unparse(subscript.upper)),
             )
+        elif not self._unevaluated and not isinstance(subscript, ast.Num):
+            raise ClassiqInternalExpansionError("Unevaluated subscript")
         else:
             handle = SubscriptHandleBinding(
                 base_handle=base_handle,
                 index=Expression(expr=ast.unparse(subscript)),
             )
         if not self._is_nested:
-            self._var_handles[handle] = True
+            self._add_handle(handle)
         return handle
 
     def visit_Name(self, node: ast.Name) -> Optional[HandleBinding]:
@@ -164,16 +145,31 @@ class VarRefCollector(ast.NodeVisitor):
             return None
         handle = HandleBinding(name=node.id)
         if not self._is_nested:
-            self._var_handles[handle] = True
+            self._add_handle(handle)
         return handle
 
     @contextmanager
-    def set_nested(self) -> Iterator[None]:
+    def set_nested(self, val: bool = True) -> Iterator[None]:
         previous_is_nested = self._is_nested
-        self._is_nested = True
+        self._is_nested = val
         yield
         self._is_nested = previous_is_nested
 
+    @contextmanager
+    def set_in_subscript(self) -> Iterator[None]:
+        previous_in_subscript = self._in_subscript
+        self._in_subscript = True
+        with self.set_nested(False):
+            yield
+        self._in_subscript = previous_in_subscript
+
+    def _add_handle(self, handle: HandleBinding) -> None:
+        if handle not in self._var_handles:
+            self._var_handles[handle] = self._in_subscript
+            return
+        if self._in_subscript and not self._var_handles[handle]:
+            self._var_handles[handle] = True
+
 
 class VarRefTransformer(ast.NodeTransformer):
     def __init__(self, var_mapping: dict[str, str]) -> None:

classiq/open_library/functions/linear_pauli_rotation.py

@@ -42,14 +42,14 @@ def linear_pauli_rotations(
     Corresponds to the braket notation:
 
     $$
-    \\left|x\right\rangle _{n}\\left|q\right\rangle
-    _{m}\rightarrow\\left|x\right\rangle
-    _{n}\\prod_{k=1}^{m}\\left(\\cos\\left(\frac{a_{k}}{2}x+\frac{b_{k}}{2}\right)-
-    i\\sin\\left(\frac{a_{k}}{2}x+\frac{b_{k}}{2}\right)P_{k}\right)\\left|q_{k}\right\rangle
+    \\left|x\\right\\rangle _{n}\\left|q\\right\\rangle
+    _{m}\\rightarrow\\left|x\\right\\rangle
+    _{n}\\prod_{k=1}^{m}\\left(\\cos\\left(\\frac{a_{k}}{2}x+\\frac{b_{k}}{2}\\right)-
+    i\\sin\\left(\\frac{a_{k}}{2}x+\\frac{b_{k}}{2}\\right)P_{k}\\right)\\left|q_{k}\\right\\rangle
     $$
 
-    where $\\left|x\right\rangle$ is the control register,
-    $\\left|q\right\rangle$ is the target register, each $P_{k}$ is one of
+    where $\\left|x\\right\\rangle$ is the control register,
+    $\\left|q\\right\\rangle$ is the target register, each $P_{k}$ is one of
     the three Pauli matrices $X$, $Y$, or $Z$, and $a_{k}$, $b_{k}$ are
     the user given slopes and offsets, respectively.
 

classiq/open_library/functions/state_preparation.py

@@ -353,7 +353,7 @@ def _load_phases(
 @qfunc
 def inplace_prepare_complex_amplitudes(
     magnitudes: CArray[CReal],
-    phases: CArray[CReal],
+    phases: list[float],
     target: QArray[QBit, Literal["log(get_field(magnitudes, 'len'), 2)"]],
 ) -> None:
     """

classiq/open_library/functions/utility_functions.py

@@ -32,7 +32,7 @@ def apply_to_all(
 
 @qfunc
 def hadamard_transform(target: QArray[QBit]) -> None:
-    """
+    r"""
     [Qmod Classiq-library function]
 
     Applies Hadamard transform to the target qubits.
@@ -40,7 +40,7 @@ def hadamard_transform(target: QArray[QBit]) -> None:
     Corresponds to the braket notation:
 
     $$
-     H^{\\otimes n} |x\rangle = \frac{1}{\\sqrt{2^n}} \\sum_{y=0}^{2^n - 1} (-1)^{x \\cdot y} |y\rangle
+     H^{\otimes n} |x\rangle = \frac{1}{\sqrt{2^n}} \sum_{y=0}^{2^n - 1} (-1)^{x \\cdot y} |y\rangle
     $$
 
     Args:

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

@@ -65,8 +65,8 @@ class _PythonClassicalType(PythonClassicalType):
             return
 
         enum_decl = declaration_from_enum(py_type)
+        check_duplicate_types([enum_decl, *self.qmodule.user_types()])
         self.qmodule.enum_decls[py_type.__name__] = enum_decl
-        check_duplicate_types([enum_decl])
 
     def register_struct(self, py_type: type) -> TypeName:
         classical_type = super().register_struct(py_type)
@@ -74,7 +74,9 @@ class _PythonClassicalType(PythonClassicalType):
             return classical_type
         all_decls = BUILTIN_STRUCT_DECLARATIONS | self.qmodule.type_decls
         if py_type.__name__ in all_decls:
-            classical_type.set_classical_struct_decl(all_decls[py_type.__name__])
+            classical_type.set_classical_struct_decl(
+                all_decls[py_type.__name__].model_copy()
+            )
             return classical_type
 
         struct_decl = StructDeclaration(
@@ -83,8 +85,8 @@ class _PythonClassicalType(PythonClassicalType):
                 f.name: self.convert(f.type) for f in dataclasses.fields(py_type)
             },
         )
+        check_duplicate_types([struct_decl, *self.qmodule.user_types()])
         self.qmodule.type_decls[py_type.__name__] = struct_decl
-        check_duplicate_types([struct_decl])
         validate_cstruct(struct_decl)
 
         classical_type.set_classical_struct_decl(struct_decl)

classiq/qmod/model_state_container.py

@@ -1,5 +1,6 @@
 from collections import defaultdict
-from typing import TYPE_CHECKING
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Union
 
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
@@ -10,6 +11,9 @@ from classiq.interface.model.native_function_definition import (
     NativeFunctionDefinition,
 )
 
+from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
+from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
+
 if TYPE_CHECKING:
     from classiq.qmod.quantum_function import GenerativeQFunc
 
@@ -34,6 +38,22 @@ class ModelStateContainer:
         self.generative_functions = {}
         self.function_dependencies = defaultdict(list)
 
+    def user_types(
+        self,
+    ) -> Sequence[Union[EnumDeclaration, StructDeclaration, QStructDeclaration]]:
+        type_decls = [
+            t
+            for t in self.type_decls.values()
+            if t.name not in BUILTIN_STRUCT_DECLARATIONS
+        ]
+        enum_decls = [
+            t
+            for t in self.enum_decls.values()
+            if t.name not in BUILTIN_ENUM_DECLARATIONS
+        ]
+        qstruct_decls = list(self.qstruct_decls.values())
+        return [*type_decls, *enum_decls, *qstruct_decls]
+
 
 QMODULE = ModelStateContainer()
 QMODULE.reset()

classiq/qmod/native/pretty_printer.py

@@ -1,12 +1,14 @@
 from collections.abc import Mapping
 from typing import Optional, Union
 
+from classiq.interface.exceptions import ClassiqInternalError
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
     ClassicalList,
+    ClassicalTuple,
     Integer,
     Real,
 )
@@ -250,6 +252,12 @@ class DSLPrettyPrinter(ModelVisitor):
     def visit_ClassicalArray(self, ctarray: ClassicalArray) -> str:
         return f"{self.visit(ctarray.element_type)}[{ctarray.size}]"
 
+    def visit_ClassicalTuple(self, classical_tuple: ClassicalTuple) -> str:
+        raw_type = classical_tuple.get_raw_type()
+        if isinstance(raw_type, ClassicalTuple):
+            raise ClassiqInternalError("Empty tuple pretty-print not supported")
+        return self.visit(raw_type)
+
     def visit_TypeName(self, type_: TypeName) -> str:
         return type_.name