classiq 0.100.0__py3-none-any.whl → 0.104.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -1,7 +1,15 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, NoReturn, cast
 
-from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+)
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.classical_type import (
+    Bool,
+    ClassicalArray,
+    ClassicalTuple,
+    Integer,
+)
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.block import Block
@@ -20,9 +28,11 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
 )
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_type import (
+    QuantumBit,
     QuantumBitvector,
     QuantumNumeric,
     QuantumScalar,
+    QuantumType,
 )
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.variable_declaration_statement import (
@@ -31,6 +41,18 @@ from classiq.interface.model.variable_declaration_statement import (
 from classiq.interface.model.within_apply_operation import WithinApply
 
 from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import (
+    QmodType,
+    array_len,
+    element_types,
+    is_numeric_type,
+)
+from classiq.evaluators.qmod_type_inference.classical_type_inference import (
+    infer_classical_type,
+)
+from classiq.evaluators.qmod_type_inference.quantum_type_comparison import (
+    compare_quantum_types,
+)
 from classiq.evaluators.qmod_type_inference.quantum_type_inference import (
     inject_quantum_type_attributes_inplace,
 )
@@ -43,13 +65,22 @@ from classiq.model_expansions.quantum_operations.arithmetic.explicit_boolean_exp
     validate_assignment_bool_expression,
 )
 from classiq.model_expansions.quantum_operations.emitter import Emitter
-from classiq.model_expansions.scope import ClassicalSymbol
+from classiq.model_expansions.scope import ClassicalSymbol, QuantumSymbol
 from classiq.qmod.builtins.functions.standard_gates import CX
 
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 
 
+def _get_expr_type(op: QuantumAssignmentOperation) -> QmodType:
+    expr_val = op.expression.value.value
+    if isinstance(expr_val, QmodAnnotatedExpression):
+        return expr_val.get_type(expr_val.root)
+    else:
+        expr_type = infer_classical_type(expr_val)
+    return expr_type
+
+
 class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
     def __init__(
         self, interpreter: "BaseInterpreter", replace_assignment_if_needed: bool = False
@@ -60,14 +91,26 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
     def emit(self, op: QuantumAssignmentOperation, /) -> bool:
         result_symbol = self._interpreter.evaluate(op.result_var).value
         if isinstance(result_symbol, ClassicalSymbol):
-            return False
+            return self._emit_classical_assignment(op)
+        if isinstance(result_symbol.quantum_type, QuantumScalar):
+            return self._emit_scalar_assignment(op)
+        expr_val = op.expression.value.value
+        if isinstance(expr_val, QmodAnnotatedExpression) and isinstance(
+            expr_val.get_type(expr_val.root), QuantumType
+        ):
+            return self._emit_quantum_var_quantum_expr_assignment(op)
+        return self._emit_quantum_var_classical_expr_assignment(op)
+
+    def _emit_classical_assignment(self, _: QuantumAssignmentOperation, /) -> bool:
+        return False
+
+    def _emit_scalar_assignment(self, op: QuantumAssignmentOperation, /) -> bool:
+        result_symbol = self._interpreter.evaluate(op.result_var).value
         result_type = result_symbol.quantum_type
-        if not isinstance(result_type, QuantumScalar):
-            raise ClassiqExpansionError(
-                f"Cannot assign into a non-scalar quantum variable "
-                f"{str(result_symbol.handle)!r} of type "
-                f"{result_type.raw_qmod_type_name}"
-            )
+
+        expr_type = _get_expr_type(op)
+        if not is_numeric_type(expr_type) and not isinstance(expr_type, Bool):
+            self._raise_type_error(result_symbol, expr_type)
 
         if not (
             isinstance(op, ArithmeticOperation)
@@ -82,36 +125,73 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         )
         convert_assignment_bool_expression(op)
 
-        expression_type = self._infer_expression_type(op)
-        if expression_type is None:
+        quantum_expr_type = self._infer_scalar_expression_type(op)
+        if quantum_expr_type is None:
             return False
 
         if not result_type.is_instantiated:
-            if not inject_quantum_type_attributes_inplace(expression_type, result_type):
-                raise ClassiqExpansionError(
-                    f"Cannot assign expression of type "
-                    f"{expression_type.qmod_type_name} to variable "
-                    f"{str(result_symbol)!r} of type "
-                    f"{result_symbol.quantum_type.qmod_type_name}"
-                )
+            if not inject_quantum_type_attributes_inplace(
+                quantum_expr_type, result_type
+            ):
+                self._raise_type_error(result_symbol, expr_type)
             return False
 
-        if isinstance(result_type, QuantumNumeric) and isinstance(
-            expression_type, QuantumNumeric
+        if not isinstance(result_type, QuantumScalar) or not isinstance(
+            quantum_expr_type, QuantumScalar
         ):
-            result_type.set_bounds(expression_type.get_bounds())
-        if self._same_numeric_attributes(result_type, expression_type):
+            return False
+        if isinstance(result_type, QuantumNumeric):
+            result_type.set_bounds(quantum_expr_type.get_bounds())
+        if self._same_numeric_attributes(result_type, quantum_expr_type):
             return False
         self._validate_declared_attributes(
-            result_type, expression_type, str(op.result_var)
+            result_type, quantum_expr_type, str(op.result_var)
         )
         if not self._replace_assignment_if_needed:
             return False
 
-        self._assign_to_inferred_var_and_bind(op, result_type, expression_type)
+        self._assign_to_inferred_var_and_bind(op, result_type, quantum_expr_type)
         return True
 
-    def _infer_expression_type(self, op: ArithmeticOperation) -> QuantumScalar | None:
+    def _emit_quantum_var_quantum_expr_assignment(
+        self, op: QuantumAssignmentOperation, /
+    ) -> bool:
+        result_symbol = self._interpreter.evaluate(op.result_var).value
+        result_type = result_symbol.quantum_type
+        expr_type = cast(QuantumType, _get_expr_type(op))
+        if not inject_quantum_type_attributes_inplace(
+            expr_type, result_type
+        ) or not compare_quantum_types(result_type, expr_type):
+            self._raise_type_error(result_symbol, expr_type)
+        return False
+
+    def _emit_quantum_var_classical_expr_assignment(
+        self, op: QuantumAssignmentOperation, /
+    ) -> bool:
+        result_symbol = self._interpreter.evaluate(op.result_var).value
+        result_type = result_symbol.quantum_type
+
+        quantum_expr_type = self._infer_classical_array_expression_type(op)
+        if quantum_expr_type is None or not inject_quantum_type_attributes_inplace(
+            quantum_expr_type, result_type
+        ):
+            self._raise_type_error(result_symbol, _get_expr_type(op))
+
+        return False
+
+    def _raise_type_error(
+        self, result_symbol: QuantumSymbol, expr_type: QmodType
+    ) -> NoReturn:
+        raise ClassiqExpansionError(
+            f"Cannot assign expression of type "
+            f"{expr_type.qmod_type_name} to variable "
+            f"{str(result_symbol)!r} of type "
+            f"{result_symbol.quantum_type.qmod_type_name}"
+        )
+
+    def _infer_scalar_expression_type(
+        self, op: QuantumAssignmentOperation
+    ) -> QuantumType | None:
         expr = self._evaluate_expression(op.expression)
         expr_val = expr.value.value
         if isinstance(expr_val, QmodAnnotatedExpression):
@@ -129,9 +209,33 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
             ).to_quantum_numeric()
         return None
 
+    def _infer_classical_array_expression_type(
+        self, op: QuantumAssignmentOperation
+    ) -> QuantumType | None:
+        expr = self._evaluate_expression(op.expression)
+        expr_val = expr.value.value
+        if isinstance(expr_val, QmodAnnotatedExpression):
+            root_type = expr_val.get_type(expr_val.root)
+            if isinstance(root_type, (ClassicalArray, ClassicalTuple)) and all(
+                isinstance(element_type, Integer)
+                for element_type in element_types(root_type)
+            ):
+                list_len = array_len(root_type)
+                len_expr = (
+                    Expression(expr=str(list_len)) if list_len is not None else None
+                )
+                return QuantumBitvector(element_type=QuantumBit(), length=len_expr)
+            return None
+        if isinstance(expr_val, list) and all(
+            element in (0, 1) for element in expr_val
+        ):
+            length_expr = Expression(expr=str(len(expr_val)))
+            return QuantumBitvector(element_type=QuantumBit(), length=length_expr)
+        return None
+
     @staticmethod
     def _same_numeric_attributes(
-        result_type: QuantumNumeric, expression_type: QuantumScalar
+        result_type: QuantumScalar, expression_type: QuantumScalar
     ) -> bool:
         return (
             result_type.size_in_bits == expression_type.size_in_bits
@@ -142,7 +246,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
 
     @classmethod
     def _validate_declared_attributes(
-        cls, result_type: QuantumNumeric, expression_type: QuantumScalar, var: str
+        cls, result_type: QuantumScalar, expression_type: QuantumScalar, var: str
     ) -> None:
         result_size, result_sign, result_fractions = (
             result_type.size_in_bits,

classiq/model_expansions/quantum_operations/bind.py

@@ -97,6 +97,8 @@ class BindEmitter(Emitter[BindOperation]):
             state = self._builder.current_block.captured_vars.get_state(
                 var_name, inp.defining_function
             )
+            if state is None:
+                continue
             if not state:
                 raise ClassiqExpansionError(
                     f"Cannot use uninitialized quantum variable "
@@ -112,6 +114,8 @@ class BindEmitter(Emitter[BindOperation]):
             state = self._builder.current_block.captured_vars.get_state(
                 var_name, out.defining_function
             )
+            if state is None:
+                continue
             if state:
                 raise ClassiqExpansionError(
                     f"Cannot use initialized quantum variable "

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -12,9 +12,6 @@ from classiq.interface.debug_info.debug_info import (
     new_function_debug_info_by_node,
 )
 from classiq.interface.exceptions import ClassiqExpansionError
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.helpers.text_utils import are, readable_list, s
 from classiq.interface.model.block import Block
@@ -45,8 +42,6 @@ from classiq.evaluators.parameter_types import (
 )
 from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.model_expansions.capturing.captured_vars import (
-    INITIALIZED_VAR_MESSAGE,
-    UNINITIALIZED_VAR_MESSAGE,
     validate_args_are_not_propagated,
 )
 from classiq.model_expansions.closure import Closure, FunctionClosure
@@ -109,12 +104,14 @@ def _validate_gen_args(
         if (
             isinstance(param, ClassicalParameterDeclaration)
             and not param.classical_type.is_purely_declarative
-            and isinstance(arg.value, QmodAnnotatedExpression)
+            and isinstance(arg_val := arg.value, QmodAnnotatedExpression)
         ):
             readable_expr = transform_expression(str(arg.value), {}, {}, one_line=True)
+            expr_type = arg_val.get_type(arg_val.root)
             raise ClassiqExpansionError(
-                f"Cannot pass symbolic expression {readable_expr!r} as Python-type "
-                f"parameter {param.name!r}"
+                f"Cannot pass {readable_expr!r} of type {expr_type.qmod_type_name} as "
+                f"parameter {param.name!r} of Python-type "
+                f"{param.classical_type.python_type_name}"
             )
 
 
@@ -195,7 +192,6 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
     ) -> QuantumFunctionCall:
         function = function.clone()
         function = function.set_depth(self._builder.current_function.depth + 1)
-        self._validate_call_args(function.positional_arg_declarations, args)
         evaluated_args = [self._interpreter.evaluate(arg) for arg in args]
         _validate_cloning(evaluated_args)
         _validate_runtime_args(evaluated_args, self._current_scope)
@@ -391,32 +387,6 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
             permutation=function.permutation,
         )
 
-    def _validate_call_args(
-        self, params: Sequence[PositionalArg], args: list[ArgValue]
-    ) -> None:
-        for param, arg in zip(params, args):
-            if not isinstance(param, PortDeclaration) or not isinstance(
-                arg, HandleBinding
-            ):
-                continue
-            var_name = arg.name
-            symbol = self._interpreter.evaluate(var_name)
-            if (
-                not isinstance(symbol.value, QuantumSymbol)
-                or symbol.defining_function is None
-            ):
-                continue
-            var_state = self._builder.current_block.captured_vars.get_state(
-                var_name, symbol.defining_function
-            )
-            if not var_state and param.direction in (
-                PortDeclarationDirection.Inout,
-                PortDeclarationDirection.Input,
-            ):
-                raise ClassiqExpansionError(UNINITIALIZED_VAR_MESSAGE.format(var_name))
-            if var_state and param.direction == PortDeclarationDirection.Output:
-                raise ClassiqExpansionError(INITIALIZED_VAR_MESSAGE.format(var_name))
-
     def _validate_type_modifiers(
         self, func_context: FunctionContext, func_def: NativeFunctionDefinition
     ) -> None:

classiq/model_expansions/quantum_operations/emitter.py

@@ -144,11 +144,8 @@ class Emitter(Generic[QuantumStatementT], ABC):
         expression: Expression,
         *,
         simplify: bool = False,
-        treat_qnum_as_float: bool = False,
     ) -> Expression:
-        expr_val = self._interpreter.evaluate(
-            expression, simplify=simplify, treat_qnum_as_float=treat_qnum_as_float
-        ).value
+        expr_val = self._interpreter.evaluate(expression, simplify=simplify).value
         new_expr = Expression(expr=str(expr_val))
         new_expr._evaluated_expr = EvaluatedExpression(value=expr_val)
         return new_expr

classiq/model_expansions/quantum_operations/expression_evaluator.py

@@ -26,14 +26,12 @@ class ExpressionEvaluator(Emitter[QuantumOperation]):
         *,
         readable_expression_name: str | None = None,
         simplify: bool = False,
-        treat_qnum_as_float: bool = False,
         allow_link_time_vars: bool = True,
         allow_runtime_vars: bool = True,
     ) -> None:
         super().__init__(interpreter)
         self._expression_name = expression_name
         self._simplify = simplify
-        self._treat_qnum_as_float = treat_qnum_as_float
         self._allow_link_time_vars = allow_link_time_vars
         self._allow_runtime_vars = allow_runtime_vars
         if (
@@ -49,7 +47,6 @@ class ExpressionEvaluator(Emitter[QuantumOperation]):
         evaluated_expression = self._evaluate_expression(
             expression,
             simplify=self._simplify,
-            treat_qnum_as_float=self._treat_qnum_as_float,
         )
         for symbol in self._get_symbols_in_expression(evaluated_expression):
             self._capture_handle(symbol.handle, PortDeclarationDirection.Inout)

classiq/model_expansions/visitors/uncomputation_signature_inference.py

@@ -1,4 +1,3 @@
-import warnings
 from collections import defaultdict
 from collections.abc import Iterator
 from contextlib import contextmanager
@@ -6,10 +5,8 @@ from typing import NamedTuple
 
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.exceptions import (
-    ClassiqDeprecationWarning,
     ClassiqInternalExpansionError,
 )
-from classiq.interface.generator.compiler_keywords import EXPANDED_KEYWORD
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
@@ -24,9 +21,6 @@ from classiq.interface.model.invert import Invert
 from classiq.interface.model.model_visitor import ModelStatementsVisitor
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.power import Power
-from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
-    AmplitudeLoadingOperation,
-)
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
 )
@@ -35,6 +29,8 @@ from classiq.interface.model.skip_control import SkipControl
 from classiq.interface.model.within_apply_operation import WithinApply
 from classiq.interface.source_reference import SourceReference
 
+from classiq.qmod.semantics.error_manager import ErrorManager
+
 
 class _BoundVars(NamedTuple):
     in_identifiers: list[str]
@@ -148,12 +144,6 @@ class UncomputationSignatureInference(ModelStatementsVisitor):
         else:
             self._mark_as_non_const(arith.result_var.name, True)
 
-    def visit_AmplitudeLoadingOperation(
-        self, amp_load: AmplitudeLoadingOperation
-    ) -> None:
-        self._mark_as_non_permutation()
-        self._mark_as_non_const(amp_load.result_var.name, False)
-
     def visit_Control(self, control: Control) -> None:
         self.visit(control.body)
         if control.else_block is not None:
@@ -243,11 +233,7 @@ def infer_and_validate_uncomputation_signature(
             PortDeclarationDirection.Input,
             PortDeclarationDirection.Output,
         ):
-            warnings.warn(
-                _input_output_const(port.name, port.direction, func_def.name),
-                ClassiqDeprecationWarning,
-                stacklevel=1,
-            )
+            ErrorManager().add_error(_input_output_const(port.name, port.direction))
 
     if disable_perm_check and (disable_const_checks is True) and not tighten_signature:
         return
@@ -257,10 +243,9 @@ def infer_and_validate_uncomputation_signature(
 
     if not disable_perm_check and func_def.permutation and not visitor.is_permutation():
         for source_ref in visitor.non_permutation_reasons():
-            warnings.warn(
-                _non_permutation_usage(func_def.name, source_ref),
-                ClassiqDeprecationWarning,
-                stacklevel=1,
+            ErrorManager().add_error(
+                _non_permutation_usage(),
+                source_ref=source_ref,
             )
 
     if tighten_signature and not func_def.permutation and visitor.is_permutation():
@@ -276,10 +261,8 @@ def infer_and_validate_uncomputation_signature(
             and not visitor.is_const(port.name)
         ):
             for source_ref in visitor.non_const_reasons(port.name):
-                warnings.warn(
-                    _non_const_usage(port.name, source_ref),
-                    ClassiqDeprecationWarning,
-                    stacklevel=1,
+                ErrorManager().add_error(
+                    _non_const_usage(port.name), source_ref=source_ref
                 )
 
         if (
@@ -293,36 +276,21 @@ def infer_and_validate_uncomputation_signature(
 def _input_output_const(
     port_name: str,
     direction: PortDeclarationDirection,
-    function_name: str,
 ) -> str:
-    return (
-        f"{direction.capitalize()} parameters cannot be defined as constants"
-        f" (parameter {port_name!r} in function {function_name.split('_' + EXPANDED_KEYWORD)[0]!r}).\n"
-        "The deprecation warning will be elevated to an error starting 2025-12-03, at the earliest."
-    )
+    return f"{direction.capitalize()} parameter {port_name!r} cannot be defined as constant."
 
 
-def _non_const_usage(
-    port_name: str,
-    source_ref: SourceReference | None = None,
-) -> str:
-    source_ref_str = f"\n\tat {source_ref}" if source_ref else ""
+def _non_const_usage(port_name: str) -> str:
     return (
-        f"Non-constant usage of a constant parameter {port_name!r}.{source_ref_str}\n"
+        f"Non-constant usage of a constant parameter {port_name!r}.\n"
         "Tip: if the commulative use of the parameter in the function is constant, "
-        "use the `disable_const_checks` flag to instruct the compiler to disregard individual operations.\n"
-        "The deprecation warning will be elevated to an error starting 2025-12-03, at the earliest."
+        "use the `disable_const_checks` flag to instruct the compiler to disregard individual operations."
     )
 
 
-def _non_permutation_usage(
-    function_name: str,
-    source_ref: SourceReference | None = None,
-) -> str:
-    source_ref_str = f"\n\tat {source_ref}" if source_ref else ""
+def _non_permutation_usage() -> str:
     return (
-        f"Non-permutation operation used in a permutation function {function_name.split('_' + EXPANDED_KEYWORD)[0]!r}.{source_ref_str}\n"
+        "Non-permutation operation used in a permutation function.\n"
         "Tip: if the commulative effect of the function is a permutation, "
-        "use the `disable_perm_check` flag to instruct the compiler to disregard individual operations.\n"
-        "The deprecation warning will be elevated to an error starting 2025-12-03, at the earliest."
+        "use the `disable_perm_check` flag to instruct the compiler to disregard individual operations."
     )

classiq/open_library/functions/__init__.py

@@ -15,13 +15,13 @@ from .hea import *
 from .lcu import *
 from .linear_pauli_rotation import *
 from .linear_pauli_rotation import _single_pauli
-from .modular_exponentiation import *
-from .modular_exponentiation import _check_msb
+from .modular_arithmetics import *
 from .qaoa_penalty import *
 from .qft_functions import *
+from .qft_space_arithmetics import *
+from .qft_space_arithmetics import _check_msb
 from .qpe import *
-from .qsvt import gqsp
-from .qsvt_temp import *  # change to .qsvt after deprecation
+from .qsvt import *  # change to .qsvt after deprecation
 from .state_preparation import *
 from .state_preparation import _prepare_uniform_trimmed_state_step
 from .swap_test import *
@@ -31,6 +31,7 @@ from .variational import *
 OPEN_LIBRARY_FUNCTIONS: list[BaseQFunc] = [
     qpe_flexible,
     qpe,
+    _check_msb,
     _single_pauli,
     linear_pauli_rotations,
     amplitude_estimation,
@@ -45,25 +46,14 @@ OPEN_LIBRARY_FUNCTIONS: list[BaseQFunc] = [
     apply_to_all,
     qft_no_swap,
     qft_space_add_const,
-    cc_modular_add,
-    c_modular_multiply,
     multiswap,
-    inplace_c_modular_multiply,
-    modular_exp,
-    qsvt_step_old,
-    qsvt_step_new,
-    qsvt_old,
-    qsvt_new,
-    projector_controlled_double_phase_old,
-    projector_controlled_double_phase_new,
-    projector_controlled_phase_old,
-    projector_controlled_phase_new,
-    qsvt_inversion_old,
-    qsvt_inversion_new,
-    qsvt_lcu_old,
-    qsvt_lcu_new,
-    qsvt_lcu_step_old,
-    qsvt_lcu_step_new,
+    qsvt_step,
+    qsvt,
+    projector_controlled_double_phase,
+    projector_controlled_phase,
+    qsvt_inversion,
+    qsvt_lcu,
+    qsvt_lcu_step,
     gqsp,
     qaoa_mixer_layer,
     qaoa_cost_layer,
@@ -89,7 +79,6 @@ OPEN_LIBRARY_FUNCTIONS: list[BaseQFunc] = [
     _prepare_uniform_trimmed_state_step,
     _qct_d_operator,
     _qct_pi_operator,
-    _check_msb,
     encode_in_angle,
     encode_on_bloch,
     _cond_phase_flip,
@@ -99,6 +88,22 @@ OPEN_LIBRARY_FUNCTIONS: list[BaseQFunc] = [
     one_hot_to_unary,
     inplace_one_hot_to_unary,
     unary_to_one_hot,
+    modular_negate_inplace,
+    modular_subtract_inplace,
+    modular_double_inplace,
+    modular_add_constant_inplace,
+    modular_add_inplace,
+    modular_multiply,
+    modular_square,
+    modular_multiply_constant,
+    modular_multiply_constant_inplace,
+    modular_to_montgomery_inplace,
+    modular_montgomery_to_standard_inplace,
+    modular_inverse_inplace,
+    kaliski_iteration,
+    modular_rsub_inplace,
+    modular_exp,  # TODO: deprecate when ready
+    modular_exponentiate,
 ]
 
 __all__ = [
@@ -109,8 +114,6 @@ __all__ = [
     "assign_amplitude_table",
     "binary_to_one_hot",
     "binary_to_unary",
-    "c_modular_multiply",
-    "cc_modular_add",
     "encode_in_angle",
     "encode_on_bloch",
     "exact_amplitude_amplification",
@@ -121,19 +124,31 @@ __all__ = [
     "grover_search",
     "hadamard_transform",
     "inplace_binary_to_one_hot",
-    "inplace_c_modular_multiply",
     "inplace_modular_multiply",
     "inplace_one_hot_to_unary",
     "inplace_prepare_complex_amplitudes",
     "inplace_prepare_int",
     "inplace_prepare_sparse_amplitudes",
+    "kaliski_iteration",
     "lcu",
     "lcu_pauli",
     "linear_pauli_rotations",
+    "modular_add_constant_inplace",
+    "modular_add_inplace",
     "modular_add_qft_space",
+    "modular_double_inplace",
     "modular_exp",
-    "modular_increment",
+    "modular_exponentiate",
+    "modular_inverse_inplace",
+    "modular_montgomery_to_standard_inplace",
     "modular_multiply",
+    "modular_multiply_constant",
+    "modular_multiply_constant_inplace",
+    "modular_negate_inplace",
+    "modular_rsub_inplace",
+    "modular_square",
+    "modular_subtract_inplace",
+    "modular_to_montgomery_inplace",
     "multiswap",
     "one_hot_to_binary",
     "one_hot_to_unary",

classiq/open_library/functions/bit_operations.py

@@ -0,0 +1,30 @@
+from classiq.open_library.functions.utility_functions import apply_to_all
+from classiq.qmod.builtins.functions.standard_gates import SWAP, X
+from classiq.qmod.builtins.operations import invert, repeat
+from classiq.qmod.qfunc import qperm
+from classiq.qmod.qmod_variable import QArray, QBit
+
+
+@qperm
+def cyclic_shift_left(reg: QArray[QBit]) -> None:
+    """
+    Performs a left shift on the quantum register array `reg` using SWAP gates.
+    """
+    n = reg.size
+    repeat(n - 1, lambda i: SWAP(reg[n - i - 1], reg[n - i - 2]))
+
+
+@qperm
+def cyclic_shift_right(reg: QArray[QBit]) -> None:
+    """
+    Performs a right shift on the quantum register array `reg` by inverting cyclic_shift_left.
+    """
+    invert(lambda: cyclic_shift_left(reg))
+
+
+@qperm
+def bitwise_negate(x: QArray[QBit]) -> None:
+    """
+    Negates each bit of the input x.
+    """
+    apply_to_all(X, x)