classiq 0.82.1__py3-none-any.whl → 0.84.0__py3-none-any.whl

classiq/open_library/functions/modular_exponentiation.py

@@ -1,5 +1,6 @@
 from classiq.open_library.functions.qft_functions import qft, qft_no_swap
 from classiq.qmod.builtins.classical_functions import qft_const_adder_phase
+from classiq.qmod.builtins.functions.allocation import free
 from classiq.qmod.builtins.functions.standard_gates import PHASE, SWAP, X
 from classiq.qmod.builtins.operations import (
     allocate,
@@ -11,7 +12,7 @@ from classiq.qmod.builtins.operations import (
 )
 from classiq.qmod.cparam import CInt
 from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_variable import QArray, QBit
+from classiq.qmod.qmod_variable import Const, Permutable, QArray, QBit
 from classiq.qmod.symbolic import min, mod_inverse
 
 
@@ -50,8 +51,10 @@ def qft_space_add_const(value: CInt, phi_b: QArray[QBit]) -> None:
     )
 
 
-@qfunc
-def cc_modular_add(n: CInt, a: CInt, phi_b: QArray[QBit], c1: QBit, c2: QBit) -> None:
+@qfunc(unchecked=["phi_b"])
+def cc_modular_add(
+    n: CInt, a: CInt, phi_b: Permutable[QArray[QBit]], c1: Const[QBit], c2: Const[QBit]
+) -> None:
     """
     [Qmod Classiq-library function]
 
@@ -69,11 +72,9 @@ def cc_modular_add(n: CInt, a: CInt, phi_b: QArray[QBit], c1: QBit, c2: QBit) ->
     ctrl: QArray[QBit] = QArray()
     aux = QBit()
 
+    allocate(aux)
     within_apply(
-        lambda: (
-            allocate(aux),
-            bind([c1, c2], ctrl),
-        ),
+        lambda: bind([c1, c2], ctrl),
         lambda: (
             control(ctrl, lambda: qft_space_add_const(a, phi_b)),
             invert(lambda: qft_space_add_const(n, phi_b)),
@@ -87,11 +88,16 @@ def cc_modular_add(n: CInt, a: CInt, phi_b: QArray[QBit], c1: QBit, c2: QBit) ->
             ),
         ),
     )
+    free(aux)
 
 
-@qfunc
+@qfunc(unchecked=["b"])
 def c_modular_multiply(
-    n: CInt, a: CInt, b: QArray[QBit], x: QArray[QBit], ctrl: QBit
+    n: CInt,
+    a: CInt,
+    b: Permutable[QArray[QBit]],
+    x: Const[QArray[QBit]],
+    ctrl: Const[QBit],
 ) -> None:
     """
     [Qmod Classiq-library function]
@@ -118,7 +124,7 @@ def c_modular_multiply(
 
 
 @qfunc
-def multiswap(x: QArray[QBit], y: QArray[QBit]) -> None:
+def multiswap(x: Permutable[QArray[QBit]], y: Permutable[QArray[QBit]]) -> None:
     """
     [Qmod Classiq-library function]
 
@@ -150,16 +156,12 @@ def inplace_c_modular_multiply(n: CInt, a: CInt, x: QArray[QBit], ctrl: QBit) ->
         x: The quantum factor.
         ctrl: The control bit.
     """
-    b: QArray[QBit] = QArray()
-
-    within_apply(
-        lambda: allocate(x.len + 1, b),
-        lambda: (
-            c_modular_multiply(n, a, b, x, ctrl),
-            control(ctrl, lambda: multiswap(x, b)),
-            invert(lambda: c_modular_multiply(n, mod_inverse(a, n), b, x, ctrl)),
-        ),
-    )
+    b: QArray[QBit] = QArray(length=x.len + 1)
+    allocate(b)
+    c_modular_multiply(n, a, b, x, ctrl)
+    control(ctrl, lambda: multiswap(x, b))
+    invert(lambda: c_modular_multiply(n, mod_inverse(a, n), b, x, ctrl))
+    free(b)
 
 
 @qfunc

classiq/open_library/functions/state_preparation.py

@@ -458,7 +458,7 @@ def prepare_dicke_state_unary_input(max_k: int, qvar: QArray[QBit]) -> None:
     """
     if qvar.len > max(1, max_k):
         _dicke_split_cycle_shift(max_k, qvar)
-        prepare_dicke_state_unary_input(qmin(max_k, qvar.len - 2), qvar[1 : qvar.len])
+        prepare_dicke_state_unary_input(min(max_k, qvar.len - 2), qvar[1 : qvar.len])
 
 
 @qfunc
@@ -483,3 +483,20 @@ def prepare_dicke_state(k: int, qvar: QArray[QBit]) -> None:
     if k > 0:
         apply_to_all(X, qvar[0:k])
         prepare_dicke_state_unary_input(k, qvar)
+
+
+@qfunc
+def prepare_basis_state(state: list[bool], arr: Output[QArray]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Initializes a quantum array in the specified basis state.
+
+    Args:
+        values: The desired basis state, given as a list of boolean values for each qubit.
+        arr: The quantum array to prepare.
+    """
+    allocate(len(state), arr)
+    for idx, value in enumerate(state):
+        if value:
+            X(arr[idx])

classiq/qmod/__init__.py

@@ -6,7 +6,7 @@ from .expression_query import get_expression_numeric_attributes
 from .qfunc import qfunc
 from .qmod_constant import QConstant
 from .qmod_parameter import Array, CArray, CBool, CInt, CReal
-from .qmod_variable import Const, Input, Output, QArray, QBit, QFree, QNum, QStruct
+from .qmod_variable import Const, Input, Output, Permutable, QArray, QBit, QNum, QStruct
 from .quantum_callable import QCallable, QCallableList
 from .write_qmod import write_qmod
 
@@ -19,7 +19,7 @@ __all__ = [
     "Input",
     "Output",
     "Const",
-    "QFree",
+    "Permutable",
     "QArray",
     "QBit",
     "QNum",

classiq/qmod/builtins/enums.py

@@ -1,7 +1,11 @@
 from enum import IntEnum
+from typing import TYPE_CHECKING
 
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 
+if TYPE_CHECKING:
+    from classiq.qmod.builtins.structs import SparsePauliOp
+
 
 class Element(IntEnum):
     H = 0
@@ -176,6 +180,25 @@ class Pauli(IntEnum):
     """Z (int): Pauli-Z matrix, represented by the integer 3. \n
     $Z = \\begin{bmatrix} 1 & 0 \\\\ 0 & -1 \\end{bmatrix}$"""
 
+    def __call__(self, index: int) -> "SparsePauliOp":
+        from classiq.qmod.builtins.structs import (
+            IndexedPauli,
+            SparsePauliOp,
+            SparsePauliTerm,
+        )
+
+        return SparsePauliOp(
+            terms=[  # type:ignore[arg-type]
+                SparsePauliTerm(
+                    paulis=[  # type:ignore[arg-type]
+                        IndexedPauli(pauli=self, index=index)  # type:ignore[arg-type]
+                    ],
+                    coefficient=1.0,  # type:ignore[arg-type]
+                )
+            ],
+            num_qubits=index + 1,  # type:ignore[arg-type]
+        )
+
 
 class QSVMFeatureMapEntanglement(IntEnum):
     FULL = 0

classiq/qmod/builtins/functions/__init__.py

@@ -71,6 +71,7 @@ CORE_LIB_DECLS = [
         single_pauli_exponent,
         commuting_paulis_exponent,
         suzuki_trotter,
+        multi_suzuki_trotter,
         parametric_suzuki_trotter,
         sparse_suzuki_trotter,
         qdrift,
@@ -132,6 +133,7 @@ __all__ = [  # noqa: RUF022
     "molecule_hartree_fock",
     "molecule_hva",
     "molecule_ucc",
+    "multi_suzuki_trotter",
     "parametric_suzuki_trotter",
     "pauli_feature_map",
     "permute",

classiq/qmod/builtins/functions/allocation.py

@@ -2,11 +2,11 @@ from typing import Literal
 
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CReal
-from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QFree
+from classiq.qmod.qmod_variable import Input, Output, Permutable, QArray, QBit
 
 
 @qfunc(external=True)
-def free(in_: QFree[Input[QArray[QBit]]]) -> None:
+def free(in_: Permutable[Input[QArray[QBit]]]) -> None:
     """
     [Qmod core-library function]
 

classiq/qmod/builtins/functions/arithmetic.py

@@ -2,7 +2,15 @@ from typing import Literal
 
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CBool, CReal
-from classiq.qmod.qmod_variable import Const, Input, Output, QArray, QBit, QFree, QNum
+from classiq.qmod.qmod_variable import (
+    Const,
+    Input,
+    Output,
+    Permutable,
+    QArray,
+    QBit,
+    QNum,
+)
 
 
 @qfunc(external=True)
@@ -26,7 +34,7 @@ def unitary(
 def add(
     left: Const[QNum],
     right: Const[QNum],
-    result: QFree[
+    result: Permutable[
         Output[
             QNum[
                 Literal["result_size"],
@@ -45,8 +53,8 @@ def add(
 @qfunc(external=True)
 def add_inplace_right(
     left: Const[QNum],
-    right: QFree[Input[QNum]],
-    result: QFree[
+    right: Permutable[Input[QNum]],
+    result: Permutable[
         Output[
             QNum[
                 Literal["result_size"],
@@ -63,20 +71,20 @@ def add_inplace_right(
 
 
 @qfunc(external=True)
-def modular_add(left: Const[QArray[QBit]], right: QFree[QArray[QBit]]) -> None:
+def modular_add(left: Const[QArray[QBit]], right: Permutable[QArray[QBit]]) -> None:
     pass
 
 
 @qfunc(external=True)
-def modular_add_constant(left: CReal, right: QFree[QNum]) -> None:
+def modular_add_constant(left: CReal, right: Permutable[QNum]) -> None:
     pass
 
 
 @qfunc(external=True)
-def integer_xor(left: Const[QArray[QBit]], right: QFree[QArray[QBit]]) -> None:
+def integer_xor(left: Const[QArray[QBit]], right: Permutable[QArray[QBit]]) -> None:
     pass
 
 
 @qfunc(external=True)
-def real_xor_constant(left: CReal, right: QFree[QNum]) -> None:
+def real_xor_constant(left: CReal, right: Permutable[QNum]) -> None:
     pass

classiq/qmod/builtins/functions/exponentiation.py

@@ -55,13 +55,11 @@ def commuting_paulis_exponent(
 
 @qfunc(external=True)
 def suzuki_trotter(
-    pauli_operator: CArray[PauliTerm],
+    pauli_operator: SparsePauliOp,  # FIXME: Rename to hamiltonian (CLS-2912)
     evolution_coefficient: CReal,
     order: CInt,
     repetitions: CInt,
-    qbv: QArray[
-        QBit, Literal["get_field(get_field(pauli_operator[0], 'pauli'), 'len')"]
-    ],
+    qbv: QArray[QBit],  # FIXME: Add length expr (CLS-2912)
 ) -> None:
     """
     [Qmod core-library function]
@@ -82,6 +80,36 @@ def suzuki_trotter(
     pass
 
 
+@qfunc(external=True)
+def multi_suzuki_trotter(
+    hamiltonians: CArray[SparsePauliOp],
+    evolution_coefficients: CArray[CReal],
+    order: CInt,
+    repetitions: CInt,
+    qbv: QArray,
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Applies the Suzuki-Trotter decomposition jointly to a sum of Hamiltonians
+    (represented as Pauli operators), each with its separate evolution coefficient,
+    approximating $\\exp{-iH_1t_1+H_2t_2+\\dots}$  with a specified order and number of
+    repetitions.
+
+    The Suzuki-Trotter decomposition is a method for approximating the exponential of a sum of operators by a product of exponentials of each operator.
+    The Suzuki-Trotter decomposition of a given order nullifies the error of the Taylor series expansion of the product of exponentials up to that order.
+    The error of a Suzuki-Trotter decomposition decreases as the order and number of repetitions increase.
+
+    Args:
+        hamiltonians: The hamitonians to be exponentiated, in sparse representation.
+        evolution_coefficients: The hamiltonian coefficients (can be link-time).
+        order: The order of the Suzuki-Trotter decomposition.
+        repetitions: The number of repetitions of the Suzuki-Trotter decomposition.
+        qbv: The target quantum variable of the exponentiation.
+    """
+    pass
+
+
 @qfunc(external=True)
 def parametric_suzuki_trotter(
     paulis: CArray[CArray[Pauli]],

classiq/qmod/builtins/functions/standard_gates.py

@@ -2,7 +2,7 @@ from typing import Literal
 
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CReal
-from classiq.qmod.qmod_variable import Const, QArray, QBit, QFree
+from classiq.qmod.qmod_variable import Const, Permutable, QArray, QBit
 
 
 @qfunc(external=True)
@@ -25,7 +25,7 @@ def H(target: QBit) -> None:
 
 
 @qfunc(external=True)
-def X(target: QFree[QBit]) -> None:
+def X(target: Permutable[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -44,7 +44,7 @@ def X(target: QFree[QBit]) -> None:
 
 
 @qfunc(external=True)
-def Y(target: QFree[QBit]) -> None:
+def Y(target: Permutable[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -370,7 +370,7 @@ def CH(ctrl: Const[QBit], target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CX(ctrl: Const[QBit], target: QFree[QBit]) -> None:
+def CX(ctrl: Const[QBit], target: Permutable[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -395,7 +395,7 @@ def CX(ctrl: Const[QBit], target: QFree[QBit]) -> None:
 
 
 @qfunc(external=True)
-def CY(ctrl: Const[QBit], target: QFree[QBit]) -> None:
+def CY(ctrl: Const[QBit], target: Permutable[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -549,7 +549,7 @@ def CPHASE(theta: CReal, ctrl: Const[QBit], target: Const[QBit]) -> None:
 
 
 @qfunc(external=True)
-def SWAP(qbit0: QFree[QBit], qbit1: QFree[QBit]) -> None:
+def SWAP(qbit0: Permutable[QBit], qbit1: Permutable[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -623,7 +623,7 @@ def U(theta: CReal, phi: CReal, lam: CReal, gam: CReal, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CCX(ctrl: Const[QArray[QBit, Literal[2]]], target: QFree[QBit]) -> None:
+def CCX(ctrl: Const[QArray[QBit, Literal[2]]], target: Permutable[QBit]) -> None:
     """
     [Qmod core-library function]
 

classiq/qmod/builtins/structs.py

@@ -1,6 +1,9 @@
 from dataclasses import dataclass, fields, is_dataclass
+from typing import Union
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.helpers.text_utils import are, readable_list, s
 
 from classiq.qmod.builtins.enums import LadderOperator, Pauli
 from classiq.qmod.cparam import CArray, CBool, CInt, CReal
@@ -56,13 +59,62 @@ class SparsePauliOp:
     Represents a collection of sparse Pauli operators.
 
     Attributes:
-        paulis (CArray[SparsePauliTerm]): The list of chosen sparse Pauli operators in the term, corresponds to a product of them. (See: SparsePauliTerm)
+        terms (CArray[SparsePauliTerm]): The list of chosen sparse Pauli terms, corresponds to a product of them. (See: SparsePauliTerm)
         num_qubits (CInt): The number of qubits in the Hamiltonian.
     """
 
-    paulis: CArray[SparsePauliTerm]
+    terms: CArray[SparsePauliTerm]
     num_qubits: CInt
 
+    def __mul__(self, obj: Union[float, "SparsePauliOp"]) -> "SparsePauliOp":
+        if isinstance(obj, (int, float, complex)):
+            return SparsePauliOp(
+                terms=[  # type:ignore[arg-type]
+                    SparsePauliTerm(
+                        paulis=term.paulis,
+                        coefficient=obj * term.coefficient,
+                    )
+                    for term in self.terms  # type:ignore[attr-defined]
+                ],
+                num_qubits=self.num_qubits,
+            )
+        if len(self.terms) != 1 or len(obj.terms) != 1:  # type:ignore[arg-type]
+            raise ClassiqValueError("Cannot attach a pauli to multiple pauli terms")
+        existing_indices = {
+            indexed_pauli.index for indexed_pauli in self.terms[0].paulis
+        }
+        added_indices = {indexed_pauli.index for indexed_pauli in obj.terms[0].paulis}
+        overlapping_indices = sorted(existing_indices.intersection(added_indices))
+        if len(overlapping_indices):
+            raise ClassiqValueError(
+                f"Pauli{s(overlapping_indices)} at "
+                f"{'indices' if len(overlapping_indices) > 1 else 'index'} "
+                f"{readable_list(overlapping_indices)} {are(overlapping_indices)} "
+                f"already assigned"
+            )
+        return SparsePauliOp(
+            terms=[  # type:ignore[arg-type]
+                SparsePauliTerm(
+                    paulis=self.terms[0].paulis + obj.terms[0].paulis,
+                    coefficient=self.terms[0].coefficient * obj.terms[0].coefficient,
+                )
+            ],
+            num_qubits=max(
+                self.num_qubits, obj.num_qubits  # type:ignore[call-overload]
+            ),
+        )
+
+    def __rmul__(self, obj: Union[float, "SparsePauliOp"]) -> "SparsePauliOp":
+        return self.__mul__(obj)
+
+    def __add__(self, other: "SparsePauliOp") -> "SparsePauliOp":
+        return SparsePauliOp(
+            terms=self.terms + other.terms,  # type:ignore[arg-type]
+            num_qubits=max(
+                self.num_qubits, other.num_qubits  # type:ignore[call-overload]
+            ),
+        )
+
 
 @dataclass
 class Position:
@@ -167,7 +219,7 @@ BUILTIN_STRUCT_DECLARATIONS = {
     struct_decl.__name__: StructDeclaration(
         name=struct_decl.__name__,
         variables={
-            field.name: PythonClassicalType().convert(field.type)
+            field.name: PythonClassicalType().convert(field.type, nested=True)
             for field in fields(struct_decl)
         },
     )

classiq/qmod/declaration_inferrer.py

@@ -19,8 +19,8 @@ from classiq.interface.generator.functions.concrete_types import ConcreteClassic
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_modifier import TypeModifier
 from classiq.interface.generator.functions.type_name import TypeName
-from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.generator.types.enum_declaration import declaration_from_enum
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
 from classiq.interface.model.classical_parameter_declaration import (
@@ -75,14 +75,15 @@ class _PythonClassicalType(PythonClassicalType):
         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__].model_copy()
+                all_decls[py_type.__name__].model_copy(deep=True)
             )
             return classical_type
 
         struct_decl = StructDeclaration(
             name=py_type.__name__,
             variables={
-                f.name: self.convert(f.type) for f in dataclasses.fields(py_type)
+                f.name: self.convert(f.type, nested=True)
+                for f in dataclasses.fields(py_type)
             },
         )
         check_duplicate_types([struct_decl, *self.qmodule.user_types()])
@@ -100,12 +101,12 @@ def python_type_to_qmod(
 
 
 def _extract_port_decl(name: Optional[str], py_type: Any) -> AnonPortDeclaration:
-    quantum_type, direction, qualifier = get_port_from_type_hint(py_type)
+    quantum_type, direction, modifier = get_port_from_type_hint(py_type)
     param = AnonPortDeclaration(
         name=None,
         direction=direction,
         quantum_type=quantum_type,
-        type_qualifier=qualifier,
+        type_modifier=modifier,
     )
     if name is not None:
         param = param.rename(name)
@@ -163,7 +164,7 @@ def _unpacked_annotated(arg_0: Any, args: Any) -> _AnnotatedAlias:
 
 def _get_param_name(py_type_args: Any) -> Optional[str]:
     if isinstance(py_type_args[-1], str) and not isinstance(
-        py_type_args[-1], (PortDeclarationDirection, TypeQualifier)
+        py_type_args[-1], (PortDeclarationDirection, TypeModifier)
     ):
         return py_type_args[-1]
     elif py_type_args[-1] is Literal:
@@ -176,7 +177,7 @@ def _validate_annotations(py_type_args: Any, py_type: Any) -> None:
     for arg in py_type_args[1:-1]:
         if (
             isinstance(arg, str)
-            and not isinstance(arg, (PortDeclarationDirection, TypeQualifier))
+            and not isinstance(arg, (PortDeclarationDirection, TypeModifier))
         ) or arg is Literal:
             raise ClassiqValueError(
                 f"Operand parameter declaration must be of the form <param-type> or "

classiq/qmod/native/pretty_printer.py

@@ -1,13 +1,13 @@
 from collections.abc import Mapping
 from typing import Optional, Union
 
+from classiq.interface.constants import DEFAULT_DECIMAL_PRECISION
 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,
@@ -19,8 +19,8 @@ from classiq.interface.generator.functions.concrete_types import (
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_modifier import TypeModifier
 from classiq.interface.generator.functions.type_name import TypeName
-from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
@@ -85,11 +85,10 @@ from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 from classiq.interface.model.within_apply_operation import WithinApply
+from classiq.interface.pretty_print.expression_to_qmod import transform_expression
 
 from classiq.open_library.functions import OPEN_LIBRARY_FUNCTIONS
-from classiq.qmod.native.expression_to_qmod import transform_expression
 from classiq.qmod.semantics.annotation.call_annotation import resolve_function_calls
-from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 
 class DSLPrettyPrinter(ModelVisitor):
@@ -196,9 +195,9 @@ class DSLPrettyPrinter(ModelVisitor):
         return f"{var_decl.name}: {self.visit(var_decl.quantum_type)}"
 
     def visit_AnonPortDeclaration(self, port_decl: AnonPortDeclaration) -> str:
-        qualifier_str = (
-            f"{port_decl.type_qualifier} "
-            if port_decl.type_qualifier in [TypeQualifier.Const, TypeQualifier.QFree]
+        modifier_str = (
+            f"{port_decl.type_modifier} "
+            if port_decl.type_modifier in [TypeModifier.Const, TypeModifier.Permutable]
             else ""
         )
         dir_str = (
@@ -208,7 +207,7 @@ class DSLPrettyPrinter(ModelVisitor):
         )
         param_name = f"{port_decl.name}: " if port_decl.name is not None else ""
         return (
-            f"{qualifier_str}{dir_str}{param_name}{self.visit(port_decl.quantum_type)}"
+            f"{modifier_str}{dir_str}{param_name}{self.visit(port_decl.quantum_type)}"
         )
 
     def visit_QuantumBit(self, qtype: QuantumBit) -> str:
@@ -248,9 +247,6 @@ class DSLPrettyPrinter(ModelVisitor):
     def visit_Bool(self, ctbool: Bool) -> str:
         return "bool"
 
-    def visit_ClassicalList(self, ctlist: ClassicalList) -> str:
-        return f"{self.visit(ctlist.element_type)}[]"
-
     def visit_ClassicalArray(self, ctarray: ClassicalArray) -> str:
         element_type = self.visit(ctarray.element_type)
         if ctarray.length is not None:

classiq/qmod/pretty_print/expression_to_python.py

@@ -6,8 +6,9 @@ from typing import Callable
 
 import numpy as np
 
+from classiq.interface.constants import DEFAULT_DECIMAL_PRECISION
+
 import classiq
-from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 IDENTIFIER = re.compile(r"[a-zA-Z_]\w*")
 BINARY_OPS: Mapping[type[ast.operator], str] = {

classiq/qmod/pretty_print/pretty_printer.py

@@ -3,13 +3,13 @@ from typing import Optional, Union, cast
 
 import black
 
+from classiq.interface.constants import DEFAULT_DECIMAL_PRECISION
 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,
@@ -21,8 +21,8 @@ from classiq.interface.generator.functions.concrete_types import (
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_modifier import TypeModifier
 from classiq.interface.generator.functions.type_name import TypeName
-from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
@@ -88,7 +88,6 @@ from classiq.interface.model.within_apply_operation import WithinApply
 import classiq
 from classiq.qmod.builtins.functions import BUILTIN_FUNCTION_DECLARATIONS
 from classiq.qmod.pretty_print.expression_to_python import transform_expression
-from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 
 class VariableDeclarationAssignment(Visitor):
@@ -210,8 +209,8 @@ class PythonPrettyPrinter(ModelVisitor):
         if len(unchecked) == 0:
             return no_unchecked_decorator
 
-        unchecked_qualifiers = (f'"{qualifier}"' for qualifier in unchecked)
-        unchecked_list = f"[{', '.join(unchecked_qualifiers)}]"
+        unchecked_modifiers = (f'"{modifier}"' for modifier in unchecked)
+        unchecked_list = f"[{', '.join(unchecked_modifiers)}]"
         return no_unchecked_decorator + f" (unchecked={unchecked_list})"
 
     def visit_QuantumFunctionDeclaration(
@@ -266,9 +265,9 @@ class PythonPrettyPrinter(ModelVisitor):
         if port_decl.direction is not PortDeclarationDirection.Inout:
             self._imports[port_decl.direction.name] = 1
             var_type = f"{port_decl.direction.name}[{var_type}]"
-        if port_decl.type_qualifier in [TypeQualifier.Const, TypeQualifier.QFree]:
-            self._imports[port_decl.type_qualifier.name] = 1
-            var_type = f"{port_decl.type_qualifier.name}[{var_type}]"
+        if port_decl.type_modifier in [TypeModifier.Const, TypeModifier.Permutable]:
+            self._imports[port_decl.type_modifier.name] = 1
+            var_type = f"{port_decl.type_modifier.name}[{var_type}]"
         return var_type
 
     def visit_QuantumBit(self, qtype: QuantumBit) -> str:
@@ -338,10 +337,6 @@ class PythonPrettyPrinter(ModelVisitor):
         self._imports["CBool"] = 1
         return "CBool"
 
-    def visit_ClassicalList(self, ctlist: ClassicalList) -> str:
-        self._imports["CArray"] = 1
-        return f"CArray[{self.visit(ctlist.element_type)}]"
-
     def visit_ClassicalArray(self, ctarray: ClassicalArray) -> str:
         self._imports["CArray"] = 1
         element_type = self.visit(ctarray.element_type)