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

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

@@ -4,6 +4,7 @@ import itertools
 import warnings
 from collections.abc import Collection, Iterator, Sequence
 from contextlib import contextmanager
+from typing import Optional, Union
 
 from classiq.interface.exceptions import (
     ClassiqDeprecationWarning,
@@ -12,12 +13,13 @@ 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
 from classiq.interface.model.invert import Invert
 from classiq.interface.model.model_visitor import ModelVisitor
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.power import Power
@@ -31,41 +33,50 @@ 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.interface.source_reference import SourceReference
 
 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,
+    source_ref: Optional[Union[SourceReference, str]] = None,
 ) -> str:
+    source_ref_str = f"\n\tat {source_ref}" if source_ref else ""
     return (
-        f"The type modifier of variable '{port_name}' does not conform to the function signature: "
+        f"The use of variable '{port_name}' does not conform to its declared modifier: "
         f"expected '{expected.name}', but found '{actual.name}'.\n"
-        f"Tip: If the final role of the variable in the function matches '{expected.name}', "
-        f"you may use the `unchecked` flag to instruct the compiler to disregard individual operations.\n"
-        # TODO add earliest date of enforcement. See https://classiq.atlassian.net/browse/CLS-2709.
+        f"Tip: If the cumulative use of the variable in the function matches '{expected.name}', "
+        f"use the `unchecked` flag to instruct the compiler to disregard individual operations."
+        f"{source_ref_str}\n"
+        "The deprecation warning will be elevated to an error starting July 23, 2025, at the earliest."
     )
 
 
-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],
+    source_ref: Optional[Union[SourceReference, str]] = None,
 ) -> 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()
     )
+    source_ref_str = f"\n\tat {source_ref}" if source_ref else ""
     return (
-        f"The variable binding has inconsistent type modifiers: "
+        f"Inconsistent modifiers in variable binding: "
         f"Expected modifier: {expected.name}, Actual modifiers: {actual}"
-        # TODO add earliest date of enforcement. See https://classiq.atlassian.net/browse/CLS-2709.
+        f"{source_ref_str}\n"
+        "The deprecation warning will be elevated to an error starting July 23, 2025, at the earliest."
     )
 
 
-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 +88,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
@@ -85,13 +96,14 @@ class TypeQualifierValidation(ModelVisitor):
             support_unused_ports  # could be turned off for debugging
         )
         self._skip_validation = skip_validation
+        self._source_ref: Optional[Union[SourceReference, str]] = None
 
     @contextmanager
     def validate_ports(
         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 +111,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
@@ -119,27 +131,38 @@ class TypeQualifierValidation(ModelVisitor):
         finally:
             self._conjugation_context = previous_context
 
+    @contextmanager
+    def source_reference_context(
+        self, source_ref: Optional[Union[SourceReference, str]]
+    ) -> Iterator[None]:
+        previous_source_ref = self._source_ref
+        self._source_ref = source_ref
+        try:
+            yield
+        finally:
+            self._source_ref = previous_source_ref
+
     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 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,64 +170,68 @@ 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, self._source_ref
                 ),
                 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,
-        ports: Collection[PortDeclaration],
-        body: Sequence[QuantumStatement],
+        func_def: NativeFunctionDefinition,
         unchecked: Collection[str],
     ) -> None:
-        with self.validate_ports(ports, unchecked) as should_validate:
+        with (
+            self.validate_ports(
+                func_def.port_declarations, unchecked
+            ) as should_validate,
+            self.source_reference_context(f"function '{func_def.name}'"),
+        ):
             if should_validate:
-                self.visit(body)
+                self.visit(func_def.body)
                 self._update_bound_vars()
 
     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)
-            if port.direction is PortDeclarationDirection.Output:
-                self._add_initialized_qualifier(handle.name, port.type_qualifier)
+        with self.source_reference_context(call.source_ref):
+            for handle, port in call.handles_with_params:
+                self._validate_modifier(handle.name, port.type_modifier)
+                if port.direction is PortDeclarationDirection.Output:
+                    self._add_initialized_modifier(handle.name, port.type_modifier)
 
         if self._has_inputs(call):
             bound_vars = {
                 handle.name
                 for handle, port in call.handles_with_params
                 if port.direction is not PortDeclarationDirection.Inout
+                and handle.name not in self._unchecked
             }
             self._bound_vars.append(bound_vars)
 
@@ -216,61 +243,61 @@ 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)
+        with self.source_reference_context(alloc.source_ref):
+            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 = {
             handle.name
             for handle in itertools.chain(bind_op.in_handles, bind_op.out_handles)
+            if handle.name not in self._unchecked
         }
         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, self._source_ref
                 ),
                 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]:
@@ -281,42 +308,49 @@ class TypeQualifierValidation(ModelVisitor):
         return [handle.name for handle in vrc.var_handles]
 
     def visit_ArithmeticOperation(self, arith: ArithmeticOperation) -> None:
-        result_var = arith.result_var.name
-        self._validate_qualifier(result_var, TypeQualifier.QFree)
-        for expr_var in self._extract_expr_vars(arith):
-            self._validate_qualifier(expr_var, TypeQualifier.Const)
-        if not arith.is_inplace:
-            self._add_initialized_qualifier(result_var, TypeQualifier.QFree)
+        with self.source_reference_context(arith.source_ref):
+            result_var = arith.result_var.name
+            self._validate_modifier(result_var, TypeModifier.Permutable)
+            for expr_var in self._extract_expr_vars(arith):
+                self._validate_modifier(expr_var, TypeModifier.Const)
+            if not arith.is_inplace:
+                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)
-        for expr_var in self._extract_expr_vars(amp_load):
-            self._validate_qualifier(expr_var, TypeQualifier.Const)
+        with self.source_reference_context(amp_load.source_ref):
+            result_var = amp_load.result_var.name
+            self._validate_modifier(result_var, TypeModifier.Mutable)
+            for expr_var in self._extract_expr_vars(amp_load):
+                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)
+        with self.source_reference_context(phase_op.source_ref):
+            for expr_var in self._extract_expr_vars(phase_op):
+                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.visit(control.body)
-        if control.else_block is not None:
-            self.visit(control.else_block)
+        with self.source_reference_context(control.source_ref):
+            for control_var in self._extract_expr_vars(control):
+                self._validate_modifier(control_var, TypeModifier.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)
+        with self.source_reference_context(invert.source_ref):
+            self.visit(invert.body)
 
     def visit_Power(self, power: Power) -> None:
-        self.visit(power.body)
+        with self.source_reference_context(power.source_ref):
+            self.visit(power.body)
 
     def visit_WithinApply(self, within_apply: WithinApply) -> None:
-        with self.conjugation_context():
-            self.visit(within_apply.compute)
-        self.visit(within_apply.action)
+        with self.source_reference_context(within_apply.source_ref):
+            with self.conjugation_context():
+                self.visit(within_apply.compute)
+            self.visit(within_apply.action)
 
 
 def _merge_overlapping(bound_vars: Sequence[Collection[str]]) -> list[set[str]]:

classiq/model_expansions/visitors/symbolic_param_inference.py

@@ -10,7 +10,6 @@ from classiq.interface.generator.expressions.atomic_expression_functions import
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
-    ClassicalList,
     ClassicalTuple,
     ClassicalType,
 )
@@ -37,6 +36,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)
@@ -46,7 +52,7 @@ def set_generative_recursively(classical_type: ClassicalType) -> None:
             set_generative_recursively(field_type)
         return
     classical_type.set_generative()
-    if isinstance(classical_type, (ClassicalArray, ClassicalList)):
+    if isinstance(classical_type, ClassicalArray):
         set_generative_recursively(classical_type.element_type)
     if isinstance(classical_type, ClassicalTuple):
         for element_type in classical_type.element_types:
@@ -148,7 +154,7 @@ class SymbolicParamInference(ModelVisitor):
         for param, arg in zip_longest(params, call.positional_args):
             if (
                 not isinstance(param, AnonClassicalParameterDeclaration)
-                or param.classical_type.is_purely_generative
+                or not param.classical_type.is_purely_declarative
             ):
                 self._process_compile_time_expressions(arg)
             else:
@@ -178,10 +184,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/__init__.py

@@ -6,6 +6,7 @@ from .amplitude_estimation import *
 from .discrete_sine_cosine_transform import *
 from .discrete_sine_cosine_transform import _qct_d_operator, _qct_pi_operator
 from .grover import *
+from .grover import _cond_phase_flip
 from .hea import *
 from .linear_pauli_rotation import *
 from .linear_pauli_rotation import _single_pauli
@@ -79,6 +80,7 @@ OPEN_LIBRARY_FUNCTIONS = [
     _check_msb,
     encode_in_angle,
     encode_on_bloch,
+    _cond_phase_flip,
 ]
 
 __all__ = [
@@ -105,6 +107,7 @@ __all__ = [
     "modular_increment",
     "multiswap",
     "phase_oracle",
+    "prepare_basis_state",
     "prepare_bell_state",
     "prepare_complex_amplitudes",
     "prepare_dicke_state",

classiq/open_library/functions/amplitude_amplification.py

@@ -1,11 +1,10 @@
 from classiq.open_library.functions.grover import grover_operator
+from classiq.qmod.builtins.functions.allocation import free
 from classiq.qmod.builtins.functions.standard_gates import RY
 from classiq.qmod.builtins.operations import (
     allocate,
-    bind,
     control,
     power,
-    within_apply,
 )
 from classiq.qmod.cparam import CInt, CReal
 from classiq.qmod.qfunc import qfunc
@@ -71,21 +70,14 @@ def exact_amplitude_amplification(
     theta = pi / (4 * k + 2)
     rot_phase = 2 * acos(sin(theta) / amplitude)
 
-    extended_qvars: QArray = QArray()
-    within_apply(
-        lambda: [
-            allocate(aux),
-            bind([aux, packed_qvars], extended_qvars),
+    allocate(aux)
+    amplitude_amplification(
+        k,
+        lambda qvars_: control(qvars_[0] == 0, lambda: oracle(qvars_[1 : qvars_.size])),
+        lambda qvars_: [
+            space_transform(qvars_[1 : qvars_.size]),
+            RY(rot_phase, qvars_[0]),
         ],
-        lambda: amplitude_amplification(
-            k,
-            lambda qvars_: control(
-                qvars_[0] == 0, lambda: oracle(qvars_[1 : qvars_.size])
-            ),
-            lambda qvars_: [
-                space_transform(qvars_[1 : qvars_.size]),
-                RY(rot_phase, qvars_[0]),
-            ],
-            extended_qvars,
-        ),
+        [aux, packed_qvars],
     )
+    free(aux)

classiq/open_library/functions/discrete_sine_cosine_transform.py

@@ -11,7 +11,7 @@ from classiq.qmod.builtins.operations import (
     within_apply,
 )
 from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_variable import QArray, QBit, QNum
+from classiq.qmod.qmod_variable import Const, Permutable, QArray, QBit, QNum
 from classiq.qmod.symbolic import pi
 
 
@@ -21,13 +21,13 @@ def _b_operator(q: QBit) -> None:
 
 
 @qfunc
-def _qct_d_operator(x: QNum, q: QBit) -> None:
+def _qct_d_operator(x: Const[QNum], q: QBit) -> None:
     _b_operator(q)
     control(x == 0, lambda: invert(lambda: _b_operator(q)))
 
 
 @qfunc
-def _qct_pi_operator(x: QArray[QBit], q: QBit) -> None:
+def _qct_pi_operator(x: Permutable[QArray[QBit]], q: Const[QBit]) -> None:
     control(
         q == 1,
         lambda: [
@@ -120,8 +120,8 @@ def qct_qst_type1(x: QArray[QBit]) -> None:
     within_apply(lambda: _t_operator(x), lambda: qft(x))
 
 
-@qfunc
-def qct_qst_type2(x: QArray[QBit], q: QBit) -> None:
+@qfunc(unchecked=["q"])
+def qct_qst_type2(x: QArray[QBit], q: Const[QBit]) -> None:
     """
     [Qmod Classiq-library function]
 

classiq/open_library/functions/grover.py

@@ -10,14 +10,22 @@ from classiq.qmod.builtins.operations import (
 )
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CInt
-from classiq.qmod.qmod_variable import QArray, QBit, QNum
+from classiq.qmod.qmod_variable import Const, Permutable, QArray, QBit, QNum
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.symbolic import pi
 
 
+@qfunc(unchecked=["target"])
+def _cond_phase_flip(
+    predicate: QCallable[Permutable[QBit]], target: Const[QBit]
+) -> None:
+    within_apply(lambda: H(target), lambda: predicate(target))
+
+
 @qfunc
 def phase_oracle(
-    predicate: QCallable[QArray[QBit], QBit], target: QArray[QBit]
+    predicate: QCallable[Const[QArray[QBit]], Permutable[QBit]],
+    target: Const[QArray[QBit]],
 ) -> None:
     """
     [Qmod Classiq-library function]
@@ -42,13 +50,13 @@ def phase_oracle(
     """
     aux = QBit()
     within_apply(
-        within=lambda: (allocate(aux), X(aux), H(aux)),
-        apply=lambda: predicate(target, aux),
+        lambda: [allocate(aux), X(aux)],
+        lambda: _cond_phase_flip(lambda x: predicate(target, x), aux),
     )
 
 
-@qfunc
-def reflect_about_zero(packed_vars: QArray[QBit]) -> None:
+@qfunc(unchecked=["packed_vars"])
+def reflect_about_zero(packed_vars: Const[QArray[QBit]]) -> None:
     """
     [Qmod Classiq-library function]