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

classiq/model_expansions/transformers/{type_qualifier_inference.py → type_modifier_inference.py}

@@ -12,7 +12,7 @@ from classiq.interface.exceptions import (
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.generator.functions.type_qualifier import TypeQualifier
+from classiq.interface.generator.functions.type_modifier import TypeModifier
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.control import Control
@@ -37,8 +37,8 @@ from classiq.interface.model.within_apply_operation import WithinApply
 from classiq.model_expansions.visitors.variable_references import VarRefCollector
 
 
-def _inconsistent_type_qualifier_error(
-    port_name: str, expected: TypeQualifier, actual: TypeQualifier
+def _inconsistent_type_modifier_error(
+    port_name: str, expected: TypeModifier, actual: TypeModifier
 ) -> str:
     return (
         f"The type modifier of variable '{port_name}' does not conform to the function signature: "
@@ -49,11 +49,11 @@ def _inconsistent_type_qualifier_error(
     )
 
 
-def _inconsistent_type_qualifier_in_binding_error(
-    expected: TypeQualifier, known_qualifiers: dict[str, TypeQualifier]
+def _inconsistent_type_modifier_in_binding_error(
+    expected: TypeModifier, known_modifiers: dict[str, TypeModifier]
 ) -> str:
     actual = ", ".join(
-        f"{name}: {qualifier.name}" for name, qualifier in known_qualifiers.items()
+        f"{name}: {modifier.name}" for name, modifier in known_modifiers.items()
     )
     return (
         f"The variable binding has inconsistent type modifiers: "
@@ -62,10 +62,10 @@ def _inconsistent_type_qualifier_in_binding_error(
     )
 
 
-class TypeQualifierValidation(ModelVisitor):
+class TypeModifierValidation(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
+    the list of function calls and infers the type modifiers for each function call
     without going recursively into the function calls.
     The function definition ports are modified inplace.
     """
@@ -77,7 +77,7 @@ class TypeQualifierValidation(ModelVisitor):
         self._inferred_ports: dict[str, PortDeclaration] = dict()
         self._unchecked: set[str] = set()
 
-        self._initialized_vars: dict[str, TypeQualifier] = dict()
+        self._initialized_vars: dict[str, TypeModifier] = dict()
         self._bound_vars: list[set[str]] = []
 
         self._conjugation_context: bool = False
@@ -91,7 +91,7 @@ class TypeQualifierValidation(ModelVisitor):
         self, ports: Collection[PortDeclaration], unchecked: Collection[str]
     ) -> Iterator[bool]:
         for port in ports:
-            if port.type_qualifier is TypeQualifier.Inferred:
+            if port.type_modifier is TypeModifier.Inferred:
                 self._inferred_ports[port.name] = port
             else:
                 self._signature_ports[port.name] = port
@@ -99,7 +99,7 @@ class TypeQualifierValidation(ModelVisitor):
 
         yield len(self._inferred_ports) > 0 or (
             any(
-                port.type_qualifier is not TypeQualifier.Quantum
+                port.type_modifier is not TypeModifier.Mutable
                 for port in self._signature_ports.values()
             )
             and not self._skip_validation
@@ -123,23 +123,23 @@ class TypeQualifierValidation(ModelVisitor):
         unresolved_ports = [
             port
             for port in self._inferred_ports.values()
-            if port.type_qualifier is TypeQualifier.Inferred
+            if port.type_modifier is TypeModifier.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."
+                "All ports must have their type modifiers resolved."
             )
         for port in unresolved_ports:
-            port.type_qualifier = TypeQualifier.Const
+            port.type_modifier = TypeModifier.Const
 
-    def _validate_qualifier(self, candidate: str, qualifier: TypeQualifier) -> None:
-        if self._conjugation_context and qualifier is TypeQualifier.QFree:
-            qualifier = TypeQualifier.Const
+    def _validate_modifier(self, candidate: str, modifier: TypeModifier) -> None:
+        if self._conjugation_context and modifier is TypeModifier.Permutable:
+            modifier = TypeModifier.Const
 
         if candidate in self._inferred_ports:
-            self._inferred_ports[candidate].type_qualifier = TypeQualifier.and_(
-                self._inferred_ports[candidate].type_qualifier, qualifier
+            self._inferred_ports[candidate].type_modifier = TypeModifier.and_(
+                self._inferred_ports[candidate].type_modifier, modifier
             )
             return
 
@@ -147,34 +147,32 @@ class TypeQualifierValidation(ModelVisitor):
             return
 
         if candidate in self._signature_ports:
-            self._validate_signature_qualifier(candidate, qualifier)
+            self._validate_signature_modifier(candidate, modifier)
 
         elif candidate in self._initialized_vars:
-            self._initialized_vars[candidate] = TypeQualifier.and_(
-                self._initialized_vars[candidate], qualifier
+            self._initialized_vars[candidate] = TypeModifier.and_(
+                self._initialized_vars[candidate], modifier
             )
 
-    def _validate_signature_qualifier(
-        self, candidate: str, qualifier: TypeQualifier
+    def _validate_signature_modifier(
+        self, candidate: str, modifier: TypeModifier
     ) -> None:
-        signature_qualifier = self._signature_ports[candidate].type_qualifier
-        if signature_qualifier is not TypeQualifier.and_(
-            signature_qualifier, qualifier
-        ):
+        signature_modifier = self._signature_ports[candidate].type_modifier
+        if signature_modifier is not TypeModifier.and_(signature_modifier, modifier):
             warnings.warn(
-                _inconsistent_type_qualifier_error(
-                    candidate, signature_qualifier, qualifier
+                _inconsistent_type_modifier_error(
+                    candidate, signature_modifier, modifier
                 ),
                 ClassiqDeprecationWarning,
                 stacklevel=1,
             )
 
-    def _add_initialized_qualifier(self, var: str, qualifier: TypeQualifier) -> None:
+    def _add_initialized_modifier(self, var: str, modifier: TypeModifier) -> None:
         if var in self._inferred_ports or var in self._signature_ports:
             return
-        if self._conjugation_context and qualifier is TypeQualifier.QFree:
-            qualifier = TypeQualifier.Const
-        self._initialized_vars[var] = qualifier
+        if self._conjugation_context and modifier is TypeModifier.Permutable:
+            modifier = TypeModifier.Const
+        self._initialized_vars[var] = modifier
 
     def run(
         self,
@@ -190,15 +188,15 @@ class TypeQualifierValidation(ModelVisitor):
     def _update_bound_vars(self) -> None:
         merged_bound_vars = _merge_overlapping(self._bound_vars)
         for bound_vars in merged_bound_vars:
-            reduced_qualifier = self._get_reduced_qualifier(bound_vars)
+            reduced_modifier = self._get_reduced_modifier(bound_vars)
             for var in bound_vars:
-                self._validate_qualifier(var, reduced_qualifier)
+                self._validate_modifier(var, reduced_modifier)
 
     def visit_QuantumFunctionCall(self, call: QuantumFunctionCall) -> None:
         for handle, port in call.handles_with_params:
-            self._validate_qualifier(handle.name, port.type_qualifier)
+            self._validate_modifier(handle.name, port.type_modifier)
             if port.direction is PortDeclarationDirection.Output:
-                self._add_initialized_qualifier(handle.name, port.type_qualifier)
+                self._add_initialized_modifier(handle.name, port.type_modifier)
 
         if self._has_inputs(call):
             bound_vars = {
@@ -216,8 +214,8 @@ class TypeQualifierValidation(ModelVisitor):
         )
 
     def visit_Allocate(self, alloc: Allocate) -> None:
-        self._validate_qualifier(alloc.target.name, TypeQualifier.QFree)
-        self._add_initialized_qualifier(alloc.target.name, TypeQualifier.QFree)
+        self._validate_modifier(alloc.target.name, TypeModifier.Permutable)
+        self._add_initialized_modifier(alloc.target.name, TypeModifier.Permutable)
 
     def visit_BindOperation(self, bind_op: BindOperation) -> None:
         var_names = {
@@ -226,51 +224,49 @@ class TypeQualifierValidation(ModelVisitor):
         }
         self._bound_vars.append(var_names)
         for handle in bind_op.out_handles:
-            self._add_initialized_qualifier(handle.name, TypeQualifier.Inferred)
+            self._add_initialized_modifier(handle.name, TypeModifier.Inferred)
 
-    def _get_reduced_qualifier(self, bound_vars: set[str]) -> TypeQualifier:
-        signature_qualifier = {
-            name: self._signature_ports[name].type_qualifier
+    def _get_reduced_modifier(self, bound_vars: set[str]) -> TypeModifier:
+        signature_modifiers = {
+            name: self._signature_ports[name].type_modifier
             for name in bound_vars.intersection(self._signature_ports)
         }
-        known_inferred_qualifiers = {
-            name: self._inferred_ports[name].type_qualifier
+        known_inferred_modifiers = {
+            name: self._inferred_ports[name].type_modifier
             for name in bound_vars.intersection(self._inferred_ports)
-            if self._inferred_ports[name].type_qualifier is not TypeQualifier.Inferred
+            if self._inferred_ports[name].type_modifier is not TypeModifier.Inferred
         }
-        known_initialized_qualifiers = {
+        known_initialized_modifiers = {
             name: self._initialized_vars[name]
             for name in bound_vars.intersection(self._initialized_vars)
-            if self._initialized_vars[name] is not TypeQualifier.Inferred
+            if self._initialized_vars[name] is not TypeModifier.Inferred
         }
-        known_qualifiers = (
-            signature_qualifier
-            | known_inferred_qualifiers
-            | known_initialized_qualifiers
+        known_modifiers = (
+            signature_modifiers | known_inferred_modifiers | known_initialized_modifiers
         )
-        min_qualifier = self._get_min_qualifier(list(known_qualifiers.values()))
+        min_modifier = self._get_min_modifier(list(known_modifiers.values()))
         if not all(
-            type_qualifier is min_qualifier
-            for type_qualifier in signature_qualifier.values()
+            type_modifier is min_modifier
+            for type_modifier in signature_modifiers.values()
         ):
             warnings.warn(
-                _inconsistent_type_qualifier_in_binding_error(
-                    min_qualifier, known_qualifiers
+                _inconsistent_type_modifier_in_binding_error(
+                    min_modifier, known_modifiers
                 ),
                 ClassiqDeprecationWarning,
                 stacklevel=1,
             )
 
-        return min_qualifier
+        return min_modifier
 
     @staticmethod
-    def _get_min_qualifier(qualifiers: list[TypeQualifier]) -> TypeQualifier:
-        if len(qualifiers) == 0:
-            return TypeQualifier.Const
-        elif len(qualifiers) == 1:
-            return qualifiers[0]
+    def _get_min_modifier(modifiers: list[TypeModifier]) -> TypeModifier:
+        if len(modifiers) == 0:
+            return TypeModifier.Const
+        elif len(modifiers) == 1:
+            return modifiers[0]
         else:
-            return functools.reduce(TypeQualifier.and_, qualifiers)
+            return functools.reduce(TypeModifier.and_, modifiers)
 
     @staticmethod
     def _extract_expr_vars(expr_op: QuantumExpressionOperation) -> list[str]:
@@ -282,27 +278,27 @@ class TypeQualifierValidation(ModelVisitor):
 
     def visit_ArithmeticOperation(self, arith: ArithmeticOperation) -> None:
         result_var = arith.result_var.name
-        self._validate_qualifier(result_var, TypeQualifier.QFree)
+        self._validate_modifier(result_var, TypeModifier.Permutable)
         for expr_var in self._extract_expr_vars(arith):
-            self._validate_qualifier(expr_var, TypeQualifier.Const)
+            self._validate_modifier(expr_var, TypeModifier.Const)
         if not arith.is_inplace:
-            self._add_initialized_qualifier(result_var, TypeQualifier.QFree)
+            self._add_initialized_modifier(result_var, TypeModifier.Permutable)
 
     def visit_AmplitudeLoadingOperation(
         self, amp_load: AmplitudeLoadingOperation
     ) -> None:
         result_var = amp_load.result_var.name
-        self._validate_qualifier(result_var, TypeQualifier.Quantum)
+        self._validate_modifier(result_var, TypeModifier.Mutable)
         for expr_var in self._extract_expr_vars(amp_load):
-            self._validate_qualifier(expr_var, TypeQualifier.Const)
+            self._validate_modifier(expr_var, TypeModifier.Const)
 
     def visit_PhaseOperation(self, phase_op: PhaseOperation) -> None:
         for expr_var in self._extract_expr_vars(phase_op):
-            self._validate_qualifier(expr_var, TypeQualifier.Const)
+            self._validate_modifier(expr_var, TypeModifier.Const)
 
     def visit_Control(self, control: Control) -> None:
         for control_var in self._extract_expr_vars(control):
-            self._validate_qualifier(control_var, TypeQualifier.Const)
+            self._validate_modifier(control_var, TypeModifier.Const)
         self.visit(control.body)
         if control.else_block is not None:
             self.visit(control.else_block)

classiq/model_expansions/visitors/symbolic_param_inference.py

@@ -37,6 +37,13 @@ from classiq.interface.model.quantum_lambda_function import (
 from classiq.model_expansions.visitors.variable_references import VarRefCollector
 
 
+def handle_is_directly_used_var(handle: HandleBinding, scope_vars: set[str]) -> bool:
+    return handle.name in scope_vars and (
+        not isinstance(handle, FieldHandleBinding)
+        or handle.field not in CLASSICAL_ATTRIBUTES
+    )
+
+
 def set_generative_recursively(classical_type: ClassicalType) -> None:
     if (
         isinstance(classical_type, TypeName)
@@ -178,10 +185,7 @@ class SymbolicParamInference(ModelVisitor):
         )
         vrc.visit(ast.parse(expr))
         for handle in vrc.var_handles:
-            if handle.name in self._scope and (
-                not isinstance(handle, FieldHandleBinding)
-                or handle.field not in CLASSICAL_ATTRIBUTES
-            ):
+            if handle_is_directly_used_var(handle, set(self._scope)):
                 set_generative_recursively(self._scope[handle.name])
 
     def _process_nested_compile_time_expression(self, expr: str) -> None:

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

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/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/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/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 (
@@ -100,12 +100,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 +163,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 +176,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

@@ -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
@@ -196,9 +196,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 +208,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:

classiq/qmod/pretty_print/pretty_printer.py

@@ -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
@@ -210,8 +210,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 +266,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:

classiq/qmod/qfunc.py

@@ -107,6 +107,6 @@ def _validate_directives(
     if synthesize_separately:
         error_msg += "External functions can't be marked as synthesized separately. \n"
     if unchecked is not None and len(unchecked) > 0:
-        error_msg += "External functions can't have unchecked qualifiers."
+        error_msg += "External functions can't have unchecked modifiers."
     if error_msg:
         raise ClassiqInternalError(error_msg)

classiq/qmod/qmod_variable.py

@@ -37,8 +37,8 @@ from classiq.interface.generator.expressions.proxies.quantum.qmod_qarray_proxy i
 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.qstruct_declaration import QStructDeclaration
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
@@ -168,11 +168,11 @@ _Q = TypeVar("_Q", bound=QVar)
 Output = Annotated[_Q, PortDeclarationDirection.Output]
 Input = Annotated[_Q, PortDeclarationDirection.Input]
 Const = Annotated[
-    _Q, TypeQualifier.Const
+    _Q, TypeModifier.Const
 ]  # A constant variable, up to a phase dependent on the computational basis state
-QFree = Annotated[
-    _Q, TypeQualifier.QFree
-]  # A quantum free variable, up to a phase dependent on the computational basis state
+Permutable = Annotated[
+    _Q, TypeModifier.Permutable
+]  # A permutable ("quantum free") variable, up to a phase dependent on the computational basis state
 
 
 class QScalar(QVar, SymbolicExpr):
@@ -592,21 +592,21 @@ def get_qvar(qtype: QuantumType, origin: HandleBinding) -> "QVar":
 
 def get_port_from_type_hint(
     py_type: Any,
-) -> tuple[QuantumType, PortDeclarationDirection, TypeQualifier]:
+) -> tuple[QuantumType, PortDeclarationDirection, TypeModifier]:
     direction = PortDeclarationDirection.Inout  # default
-    qualifier = TypeQualifier.Quantum  # default
+    modifier = TypeModifier.Mutable  # default
 
     if isinstance(py_type, _AnnotatedAlias):
         quantum_type = _to_quantum_type(py_type.__origin__)
         for metadata in py_type.__metadata__:
             if isinstance(metadata, PortDeclarationDirection):
                 direction = metadata
-            elif isinstance(metadata, TypeQualifier):
-                qualifier = metadata
+            elif isinstance(metadata, TypeModifier):
+                modifier = metadata
     else:
         quantum_type = _to_quantum_type(py_type)
 
-    return quantum_type, direction, qualifier
+    return quantum_type, direction, modifier
 
 
 def _to_quantum_type(py_type: Any) -> QuantumType: