classiq 0.99.0__py3-none-any.whl → 0.102.0__py3-none-any.whl

classiq/interface/generator/quantum_program.py

@@ -10,12 +10,10 @@ from classiq.interface.compression_utils import decompress
 from classiq.interface.exceptions import (
     ClassiqDeprecationWarning,
     ClassiqMissingOutputFormatError,
-    ClassiqStateInitializationError,
 )
 from classiq.interface.execution.primitives import PrimitivesInput
 from classiq.interface.executor import quantum_code
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
-from classiq.interface.executor.register_initialization import RegisterInitialization
 from classiq.interface.generator.circuit_code.circuit_code import CircuitCodeInterface
 from classiq.interface.generator.circuit_code.types_and_constants import (
     INSTRUCTION_SET_TO_FORMAT,
@@ -29,9 +27,9 @@ from classiq.interface.generator.hardware.hardware_data import SynthesisHardware
 from classiq.interface.generator.model.model import ExecutionModel
 from classiq.interface.helpers.versioned_model import VersionedModel
 from classiq.interface.ide.visual_model import CircuitMetrics
+from classiq.interface.model.model import Model
 
 RegisterName: TypeAlias = str
-InitialConditions: TypeAlias = dict[RegisterName, int]
 
 
 class TranspiledCircuitData(CircuitCodeInterface):
@@ -56,7 +54,6 @@ def _get_formatted_utc_current_time() -> str:
 
 class QuantumProgram(VersionedModel, CircuitCodeInterface):
     hardware_data: SynthesisHardwareData
-    initial_values: InitialConditions | None = pydantic.Field(default=None)
     data: GeneratedCircuitData
     model: ExecutionModel
     transpiled_circuit: TranspiledCircuitData | None = pydantic.Field(default=None)
@@ -65,7 +62,7 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
     program_id: str = pydantic.Field(default_factory=get_uuid_as_str)
     execution_primitives_input: PrimitivesInput | None = pydantic.Field(default=None)
     synthesis_warnings: list[str] | None = pydantic.Field(default=None)
-    should_warn: bool = pydantic.Field(default=False)
+    compiled_qmod: Model | None = pydantic.Field(default=None)
 
     def __str__(self) -> str:
         return self.model_dump_json(indent=2)
@@ -85,10 +82,8 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
 
     def to_program(
         self,
-        initial_values: InitialConditions | None = None,
         instruction_set: QuantumInstructionSet | None = None,
     ) -> quantum_code.QuantumCode:
-        initial_values = initial_values or self.initial_values
         if instruction_set is not None:
             code, syntax = (
                 self.program_circuit.get_code(instruction_set),
@@ -97,40 +92,17 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
         else:
             code, syntax = self._default_program_code()
 
-        if initial_values is not None:
-            registers_initialization = self.get_registers_initialization(
-                initial_values=initial_values
-            )
-        else:
-            registers_initialization = None
         return quantum_code.QuantumCode(
             code=code,
             syntax=syntax,
-            output_qubits_map=self.data.qubit_mapping.physical_outputs,
-            registers_initialization=registers_initialization,
+            output_qubits_map=(
+                self.data.qubit_mapping.physical_outputs
+                if self._can_use_transpiled_code
+                else self.data.qubit_mapping.logical_outputs
+            ),
             synthesis_execution_data=self.data.execution_data,
         )
 
-    def _get_initialization_qubits(self, name: str) -> tuple[int, ...]:
-        qubits = self.data.qubit_mapping.logical_inputs.get(name)
-        if qubits is None:
-            raise ClassiqStateInitializationError(
-                f"Cannot initialize register {name}, it does not appear in circuit inputs"
-            )
-        return qubits
-
-    def get_registers_initialization(
-        self, initial_values: InitialConditions
-    ) -> dict[RegisterName, RegisterInitialization]:
-        return {
-            name: RegisterInitialization(
-                name=name,
-                qubits=list(self._get_initialization_qubits(name)),
-                initial_condition=init_value,
-            )
-            for name, init_value in initial_values.items()
-        }
-
     def save_results(self, filename: str | Path | None = None) -> None:
         """
         Saves quantum program results as json into a file.
@@ -148,7 +120,7 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
 
     @property
     def _can_use_transpiled_code(self) -> bool:
-        return (
+        return self.transpiled_circuit is not None and (
             self.data.execution_data is None
             or not self.data.execution_data.function_execution
         )

classiq/interface/generator/transpiler_basis_gates.py

@@ -71,9 +71,7 @@ DEFAULT_BASIS_GATES: BasisGates = SINGLE_QUBIT_GATES | BASIC_TWO_QUBIT_GATES
 ALL_GATES: BasisGates = (
     SINGLE_QUBIT_GATES | TWO_QUBIT_GATES | THREE_QUBIT_GATES | NON_UNITARY_GATES
 )
-ALL_NON_3_QBIT_GATES: BasisGates = (
-    SINGLE_QUBIT_GATES | TWO_QUBIT_GATES | NON_UNITARY_GATES
-)
+ALL_NON_3_QBIT_GATES: BasisGates = ALL_GATES - THREE_QUBIT_GATES
 
 ROUTING_TWO_QUBIT_BASIS_GATES: BasisGates = frozenset(
     ("cx", "ecr", "rzx", "ryy", "rxx", "rzz", "cy", "cz", "cp", "swap")

classiq/interface/generator/types/compilation_metadata.py

@@ -3,7 +3,7 @@ from pydantic import BaseModel, Field, NonNegativeInt, PrivateAttr
 
 class CompilationMetadata(BaseModel):
     should_synthesize_separately: bool = Field(default=False)
-    occurrences_number: NonNegativeInt = Field(default=1)
+    occurrences_number: NonNegativeInt = Field(default=0)
     _occupation_number: NonNegativeInt = PrivateAttr(default=0)
     disable_perm_check: bool = Field(default=False)
     disable_const_checks: list[str] | bool = Field(default=False)

classiq/interface/helpers/model_normalizer.py

@@ -7,10 +7,16 @@ from classiq.interface.generator.functions.classical_type import ClassicalType
 from classiq.interface.generator.functions.type_modifier import TypeModifier
 from classiq.interface.generator.visitor import Transformer, Visitor
 from classiq.interface.model.model import Model
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import AnonPortDeclaration
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 
 
 class ModelNormalizer(Visitor):
+    def __init__(self, normalize_names: bool = False) -> None:
+        self._normalize_names = normalize_names
+        self._funcs_renames: dict[str, str] = {}
+
     def visit(self, node: Any) -> None:
         if isinstance(node, ASTNode):
             node.model_config["frozen"] = False
@@ -23,8 +29,26 @@ class ModelNormalizer(Visitor):
     def visit_Model(self, model: Model) -> None:
         model.debug_info = DebugInfoCollection()
         model.functions.sort(key=lambda x: x.name)
+        self._funcs_renames = {
+            func.name: f"___func_{index}" for index, func in enumerate(model.functions)
+        }
         self.generic_visit(model)
 
+    def visit_NativeFunctionDefinition(self, func: NativeFunctionDefinition) -> None:
+        if self._normalize_names:
+            func.name = self._funcs_renames[func.name]
+        self.generic_visit(func)
+
+    def visit_QuantumFunctionCall(self, call: QuantumFunctionCall) -> None:
+        if self._normalize_names:
+            if isinstance(call.function, str):
+                if call.function in self._funcs_renames:
+                    call.function = self._funcs_renames[call.function]
+            else:
+                if call.function.name in self._funcs_renames:
+                    call.function.name = self._funcs_renames[call.function.name]
+        self.generic_visit(call)
+
     def visit_AnonPortDeclaration(self, decl: AnonPortDeclaration) -> None:
         decl.type_modifier = TypeModifier.Mutable
 

classiq/interface/helpers/text_utils.py

@@ -1,18 +1,33 @@
-def s(items: list | int) -> str:
-    if isinstance(items, list):
+from collections.abc import Sequence, Sized
+
+
+def s(items: Sized | int) -> str:
+    if isinstance(items, Sized):
         items = len(items)
     return "" if items == 1 else "s"
 
 
-def are(items: list) -> str:
+def are(items: Sized) -> str:
     return "is" if len(items) == 1 else "are"
 
 
-def they(items: list) -> str:
+def were(items: Sized) -> str:
+    return "was" if len(items) == 1 else "were"
+
+
+def an(items: Sized) -> str:
+    return "an " if len(items) == 1 else ""
+
+
+def they(items: Sized) -> str:
     return "it" if len(items) == 1 else "they"
 
 
-def readable_list(items: list, quote: bool = False) -> str:
+def conj(items: Sized) -> str:
+    return "s" if len(items) == 1 else ""
+
+
+def readable_list(items: Sequence, quote: bool = False) -> str:
     if quote:
         items = [repr(str(item)) for item in items]
     if len(items) == 1:

classiq/interface/model/bind_operation.py

@@ -46,3 +46,6 @@ class BindOperation(QuantumOperation):
             )
             for handle in self.out_handles
         ]
+
+    def inverse(self) -> "BindOperation":
+        return BindOperation(in_handles=self.out_handles, out_handles=self.in_handles)

classiq/interface/model/invert.py

@@ -1,16 +1,23 @@
 from typing import TYPE_CHECKING, Literal
 
 from classiq.interface.ast_node import ASTNodeType, reset_lists
+from classiq.interface.enum_utils import StrEnum
 from classiq.interface.model.quantum_statement import QuantumOperation
 
 if TYPE_CHECKING:
     from classiq.interface.model.statement_block import StatementBlock
 
 
+class BlockKind(StrEnum):
+    SingleCall = "single_call"
+    Compound = "compound"
+
+
 class Invert(QuantumOperation):
     kind: Literal["Invert"]
 
     body: "StatementBlock"
+    block_kind: BlockKind = BlockKind.Compound
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["body"])

classiq/interface/model/model.py

@@ -5,6 +5,7 @@ from typing import Annotated, Any, Literal, NewType
 import pydantic
 
 from classiq.interface.ast_node import ASTNode
+from classiq.interface.compression_utils import compress_pydantic, decompress
 from classiq.interface.debug_info.debug_info import DebugInfoCollection
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
@@ -96,9 +97,9 @@ class Model(VersionedModel, ASTNode):
     )
     preferences: Preferences = pydantic.Field(default_factory=Preferences)
 
-    debug_info: DebugInfoCollection = pydantic.Field(
-        default_factory=DebugInfoCollection
-    )
+    _debug_info: DebugInfoCollection | None = pydantic.PrivateAttr(default=None)
+    compressed_debug_info: bytes | None = pydantic.Field(default=None)
+
     functions_compilation_metadata: defaultdict[
         str,
         Annotated[
@@ -198,3 +199,41 @@ class Model(VersionedModel, ASTNode):
         return model.model_dump(
             exclude={"constraints", "execution_preferences", "preferences"},
         )
+
+    # TODO (CLS-4966): remove
+    @pydantic.model_validator(mode="wrap")
+    @classmethod
+    def get_deprecated_debug_info(
+        cls, data: Any, handler: pydantic.ModelWrapValidatorHandler
+    ) -> "Model":
+        model = handler(data)
+        if isinstance(data, dict) and "debug_info" in data:
+            model._debug_info = DebugInfoCollection.model_validate(data["debug_info"])
+        return model
+
+    @property
+    def debug_info(self) -> DebugInfoCollection:
+        if self._debug_info is None:
+            if self.compressed_debug_info is None:
+                self._debug_info = DebugInfoCollection()
+            else:
+                self._debug_info = DebugInfoCollection.model_validate(
+                    decompress(self.compressed_debug_info)
+                )
+
+        return self._debug_info
+
+    @debug_info.setter
+    def debug_info(self, value: DebugInfoCollection) -> None:
+        self._debug_info = value
+        self.compressed_debug_info = None
+
+    def clear_debug_info(self) -> None:
+        self._debug_info = None
+        self.compressed_debug_info = None
+
+    def compress_debug_info(self) -> None:
+        if self._debug_info is None:
+            self.compressed_debug_info = None
+        else:
+            self.compressed_debug_info = compress_pydantic(self._debug_info)

classiq/interface/model/quantum_function_call.py

@@ -29,6 +29,13 @@ from classiq.interface.model.quantum_lambda_function import (
 )
 from classiq.interface.model.quantum_statement import HandleMetadata, QuantumOperation
 
+
+def _split_concatenation(var: HandleBinding | HandlesList) -> list[HandleBinding]:
+    if isinstance(var, HandleBinding):
+        return [var]
+    return list(chain.from_iterable(_split_concatenation(item) for item in var.handles))
+
+
 ArgValue = Union[
     Expression,
     QuantumOperand,
@@ -221,18 +228,23 @@ class QuantumFunctionCall(QuantumOperation):
     def _get_handles_with_declarations(
         self,
     ) -> Iterable[tuple[int, AnonPortDeclaration, HandleBinding]]:
+        """
+        Get variable arguments attached to their position and parameter declaration.
+        Splits concatenations into variables.
+        """
         return [
-            (idx, port, handle)
-            for idx, (port, handle) in enumerate(
+            (positional_idx, port, var)
+            for positional_idx, (port, var_or_concatenation) in enumerate(
                 zip(
                     (port_decl for port_decl in self.func_decl.port_declarations),
                     (
-                        param
-                        for param in self.positional_args
-                        if isinstance(param, HandleBinding)
+                        arg
+                        for arg in self.positional_args
+                        if isinstance(arg, (HandleBinding, HandlesList))
                     ),
                 )
             )
+            for var in _split_concatenation(var_or_concatenation)
         ]
 
     def _get_readable_location(

classiq/model_expansions/arithmetic_compute_result_attrs.py

@@ -64,11 +64,20 @@ def compute_result_attrs_bitwise_and(
     if left.fraction_digits > 0 or right.fraction_digits > 0:
         raise ClassiqValueError("Bitwise AND is only defined for integers")
 
+    if left.is_signed and not right.is_signed:
+        size = right.size
+    elif not left.is_signed and right.is_signed:
+        size = left.size
+    elif not left.is_signed and not right.is_signed:
+        size = min(left.size, right.size)
+    else:
+        size = max(left.size, right.size)
+
     # we comply with python, which uses arbitrary precision, so a positive number can
     # always be represented by "0..." and a negative number by "1...", thus their
     # bitwise AND is always non-negative
     return NumericAttributes(
-        size=max(left.size, right.size),
+        size=size,
         is_signed=left.is_signed and right.is_signed,
         fraction_digits=0,
     )

classiq/model_expansions/interpreters/base_interpreter.py

@@ -159,7 +159,7 @@ class BaseInterpreter:
         finally:
             self._error_manager.report_errors(ClassiqExpansionError)
 
-        return Model(
+        model = Model(
             constraints=self._model.constraints,
             preferences=self._model.preferences,
             classical_execution_code=self._model.classical_execution_code,
@@ -181,9 +181,10 @@ class BaseInterpreter:
                 if name not in BUILTIN_STRUCT_DECLARATIONS
             ],
             qstructs=list(QMODULE.qstruct_decls.values()),
-            debug_info=self._model.debug_info,
             functions_compilation_metadata=self._expanded_functions_compilation_metadata,
         )
+        model.debug_info = self._model.debug_info
+        return model
 
     def process_exception(self, e: Exception) -> None:
         if not isinstance(e, (ClassiqError, ValidationError)):

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -286,9 +286,6 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
         if cache_key in self._expanded_functions:
             function_def = self._expanded_functions[cache_key]
             self._expand_cached_function(function, function_def)
-            self._expanded_functions_compilation_metadata[
-                function_def.name
-            ].occurrences_number += 1
             return function_def
 
         context = self._expand_operation(function)

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,
 )
@@ -35,6 +32,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]
@@ -243,11 +242,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 +252,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 +270,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 +285,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

@@ -8,19 +8,20 @@ from .amplitude_estimation import *
 from .amplitude_loading import assign_amplitude_table
 from .discrete_sine_cosine_transform import *
 from .discrete_sine_cosine_transform import _qct_d_operator, _qct_pi_operator
+from .encodings import *
 from .grover import *
 from .grover import _cond_phase_flip
 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 *
@@ -30,6 +31,7 @@ from .variational import *
 OPEN_LIBRARY_FUNCTIONS: list[BaseQFunc] = [
     qpe_flexible,
     qpe,
+    _check_msb,
     _single_pauli,
     linear_pauli_rotations,
     amplitude_estimation,
@@ -44,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,
@@ -88,13 +79,31 @@ 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,
     inplace_modular_multiply,
     modular_multiply,
     modular_add_qft_space,
+    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__ = [
@@ -103,8 +112,8 @@ __all__ = [
     "amplitude_estimation",
     "apply_to_all",
     "assign_amplitude_table",
-    "c_modular_multiply",
-    "cc_modular_add",
+    "binary_to_one_hot",
+    "binary_to_unary",
     "encode_in_angle",
     "encode_on_bloch",
     "exact_amplitude_amplification",
@@ -114,19 +123,36 @@ __all__ = [
     "grover_operator",
     "grover_search",
     "hadamard_transform",
-    "inplace_c_modular_multiply",
+    "inplace_binary_to_one_hot",
     "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",
+    "pad_zeros",
     "phase_oracle",
     "prepare_basis_state",
     "prepare_bell_state",
@@ -166,4 +192,6 @@ __all__ = [
     "suzuki_trotter",
     "swap_test",
     "switch",
+    "unary_to_binary",
+    "unary_to_one_hot",
 ]