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

classiq/model_expansions/scope.py

@@ -31,8 +31,13 @@ from classiq.interface.model.handle_binding import (
     SubscriptHandleBinding,
 )
 from classiq.interface.model.quantum_function_call import ArgValue
+from classiq.interface.model.quantum_function_declaration import (
+    AnonPositionalArg,
+    AnonQuantumOperandDeclaration,
+)
 from classiq.interface.model.quantum_type import (
     QuantumBitvector,
+    QuantumNumeric,
     QuantumType,
 )
 
@@ -184,6 +189,9 @@ class QuantumSymbolList(QuantumVariable):
             length = Expression(
                 expr=str(sum(symbol.quantum_type.size_in_bits for symbol in symbols))
             )
+        for symbol in symbols:
+            if isinstance(symbol.quantum_type, QuantumNumeric):
+                symbol.quantum_type.reset_bounds()
         return QuantumSymbolList(
             handles=handles, quantum_type=QuantumBitvector(length=length)
         )
@@ -212,7 +220,7 @@ def _evaluated_to_str_struct_literal(value: QmodStructInstance) -> str:
 
 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)
+        symbolic_vars = sorted(map(str, 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}"
@@ -240,13 +248,15 @@ class Evaluated:  # FIXME: Merge with EvaluatedExpression if possible
 
         return int(self.value)
 
-    def emit(self) -> ArgValue:
+    def emit(self, param: Optional[AnonPositionalArg] = None) -> ArgValue:
         from classiq.model_expansions.closure import 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
+        if (
+            isinstance(param, AnonQuantumOperandDeclaration)
+            and isinstance(self.value, list)
+            and all(isinstance(item, FunctionClosure) for item in self.value)
         ):
             return [item.emit() for item in self.value]
 

classiq/model_expansions/scope_initialization.py

@@ -1,12 +1,7 @@
 from collections.abc import Sequence
 
-from classiq.interface.exceptions import ClassiqError, ClassiqInternalExpansionError
+from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.constant import Constant
-from classiq.interface.generator.functions.classical_type import (
-    ClassicalArray,
-    ClassicalList,
-)
-from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -138,11 +133,3 @@ def init_top_level_scope(model: Model, scope: Scope) -> None:
 def init_builtin_types() -> None:
     QMODULE.enum_decls |= BUILTIN_ENUM_DECLARATIONS
     QMODULE.type_decls |= BUILTIN_STRUCT_DECLARATIONS
-
-
-def _get_shape(classical_type: ConcreteClassicalType) -> tuple[int, ...]:
-    if isinstance(classical_type, ClassicalList):
-        raise ClassiqInternalExpansionError("Unexpected classical list")
-    if isinstance(classical_type, ClassicalArray):
-        return classical_type.size, *_get_shape(classical_type.element_type)
-    return ()

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]
@@ -105,19 +125,8 @@ class SymbolicParamInference(ModelVisitor):
             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)
 
-    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))
         scope = dict(self._scope) | {
@@ -131,7 +140,6 @@ 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:
@@ -140,14 +148,20 @@ class SymbolicParamInference(ModelVisitor):
         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:
@@ -174,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(
@@ -184,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/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
 

classiq/qmod/pretty_print/expression_to_python.py

@@ -47,6 +47,7 @@ class ASTToQMODCode(ast.NodeVisitor):
     imports: dict[str, int]
     symbolic_imports: dict[str, int]
     decimal_precision: int
+    one_line: bool
     indent_seq: str = "    "
 
     @property
@@ -140,6 +141,10 @@ class ASTToQMODCode(ast.NodeVisitor):
             if not IDENTIFIER.match(field):
                 raise AssertionError("Error parsing struct field access.")
             return f"{self.visit(node.args[0])}.{field}"
+        elif func == "do_subscript":
+            if len(node.args) != 2:
+                raise AssertionError("Error parsing array subscript.")
+            return f"{self.visit(node.args[0])}[{self.visit(node.args[1])}]"
         elif func == "struct_literal":
             if len(node.args) != 1 or not isinstance(node.args[0], ast.Name):
                 raise AssertionError("Error parsing struct literal.")
@@ -164,7 +169,7 @@ class ASTToQMODCode(ast.NodeVisitor):
         raise AssertionError("Cannot parse node of type: " + type(node).__name__)
 
     def indent_items(self, items: Callable[[], list[str]]) -> str:
-        should_indent = (
+        should_indent = not self.one_line and (
             len("".join([i.strip() for i in items()])) >= LIST_FORMAT_CHAR_LIMIT
         )
         if should_indent:
@@ -213,10 +218,12 @@ def transform_expression(
     symbolic_imports: dict[str, int],
     level: int = 0,
     decimal_precision: int = DEFAULT_DECIMAL_PRECISION,
+    one_line: bool = False,
 ) -> str:
     return ASTToQMODCode(
         level=level,
         decimal_precision=decimal_precision,
         imports=imports,
+        one_line=one_line,
         symbolic_imports=symbolic_imports,
     ).visit(ast.parse(expr))

classiq/qmod/pretty_print/pretty_printer.py

@@ -10,6 +10,7 @@ from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
     ClassicalList,
+    ClassicalTuple,
     Integer,
     Real,
 )
@@ -345,6 +346,12 @@ class PythonPrettyPrinter(ModelVisitor):
         self._imports["CArray"] = 1
         return f"CArray[{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:
         self._import_type_name(type_)
         return type_.name

classiq/qmod/python_classical_type.py

@@ -62,7 +62,7 @@ class PythonClassicalType:
             return self.register_struct(py_type)
         elif inspect.isclass(py_type) and isinstance(py_type, EnumMeta):
             self.register_enum(py_type)
-            return Enum(name=py_type.__name__)
+            return Enum(name=py_type.__name__).set_generative()
         elif py_type in (CArray, list):
             raise ClassiqValueError(CARRAY_ERROR_MESSAGE)
         return None

classiq/qmod/qmod_parameter.py

@@ -1,10 +1,11 @@
 from typing import TYPE_CHECKING, Any, Union
 
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqInternalError, ClassiqValueError
 from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
     ClassicalList,
+    ClassicalTuple,
     ClassicalType,
     Integer,
     Real,
@@ -41,7 +42,7 @@ class CParamList(CParam):
     def __init__(
         self,
         expr: str,
-        list_type: Union[ClassicalList, ClassicalArray],
+        list_type: Union[ClassicalList, ClassicalArray, ClassicalTuple],
         qmodule: ModelStateContainer,
     ) -> None:
         super().__init__(expr)
@@ -49,9 +50,35 @@ class CParamList(CParam):
         self._list_type = list_type
 
     def __getitem__(self, key: Any) -> CParam:
-        param_type = self._list_type.element_type
-        if isinstance(key, slice):
-            param_type = self._list_type
+        param_type: ClassicalType
+        if not isinstance(key, slice):
+            if isinstance(self._list_type, ClassicalTuple):
+                if isinstance(key, int) and 0 <= key < len(
+                    self._list_type.element_types
+                ):
+                    param_type = self._list_type.element_types[key]
+                elif len(self._list_type.element_types) == 0:
+                    raise ClassiqValueError("Array is empty")
+                else:
+                    param_type = self._list_type.element_types[0].get_raw_type()
+            else:
+                param_type = self._list_type.element_type
+        else:
+            if not isinstance(self._list_type, ClassicalTuple):
+                param_type = self._list_type
+            else:
+                if (
+                    (isinstance(key.start, int) or key.start is None)
+                    and (isinstance(key.stop, int) or key.stop is None)
+                    and (isinstance(key.step, int) or key.step is None)
+                ):
+                    param_type = ClassicalTuple(
+                        element_types=self._list_type.element_types.__getitem__(key)
+                    )
+                elif len(self._list_type.element_types) == 0:
+                    param_type = self._list_type
+                else:
+                    param_type = self._list_type.element_types[0].get_raw_type()
             start = key.start if key.start is not None else ""
             stop = key.stop if key.stop is not None else ""
             if key.step is not None:
@@ -110,7 +137,7 @@ class CParamStruct(CParam):
 
         return create_param(
             f"get_field({variable_name},{field_name!r})",
-            field_type,
+            field_type.model_copy(deep=True),
             qmodule=qmodule,
         )
 
@@ -118,7 +145,11 @@ class CParamStruct(CParam):
 def create_param(
     expr_str: str, ctype: ClassicalType, qmodule: ModelStateContainer
 ) -> CParam:
-    if isinstance(ctype, (ClassicalList, ClassicalArray)):
+    if isinstance(ctype, TypeName) and ctype.has_classical_struct_decl:
+        decl = ctype.classical_struct_decl
+        ctype = Struct(name=ctype.name)
+        ctype.set_classical_struct_decl(decl)
+    if isinstance(ctype, (ClassicalList, ClassicalArray, ClassicalTuple)):
         return CParamList(expr_str, ctype, qmodule=qmodule)
     elif isinstance(ctype, Struct):
         return CParamStruct(expr_str, ctype, qmodule=qmodule)
@@ -137,6 +168,11 @@ def get_qmod_type(ctype: ClassicalType) -> type:
         return CArray[get_qmod_type(ctype.element_type)]  # type: ignore[misc]
     elif isinstance(ctype, ClassicalArray):
         return CArray[get_qmod_type(ctype.element_type), ctype.size]  # type: ignore[misc]
+    elif isinstance(ctype, ClassicalTuple):
+        raw_type = ctype.get_raw_type()
+        if isinstance(raw_type, ClassicalTuple):
+            raise ClassiqInternalError("Tuple is empty")
+        return get_qmod_type(raw_type)
     elif isinstance(ctype, TypeName):
         type_ = type(ctype.name, (TypeName,), dict())
         if isinstance(ctype, Struct):