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

classiq/interface/model/quantum_expressions/amplitude_loading_operation.py

@@ -1,77 +0,0 @@
-from collections.abc import Mapping, Sequence
-from typing import Literal
-
-import pydantic
-
-from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator.amplitude_loading import (
-    AMPLITUDE_IO_NAME,
-    TARGET_OUTPUT_NAME,
-)
-from classiq.interface.model.handle_binding import (
-    ConcreteHandleBinding,
-    HandleBinding,
-)
-from classiq.interface.model.quantum_expressions.quantum_expression import (
-    QuantumAssignmentOperation,
-)
-from classiq.interface.model.quantum_statement import HandleMetadata
-from classiq.interface.model.quantum_type import QuantumBit, QuantumNumeric, QuantumType
-
-MULTI_VARS_UNSUPPORTED_ERROR = (
-    "Amplitude Loading with more than one input variable is unsupported."
-)
-
-VAR_TYPE_ILLEGAL = "Amplitude Loading input variable should be a quantum numeric"
-
-
-class AmplitudeLoadingOperation(QuantumAssignmentOperation):
-    kind: Literal["AmplitudeLoadingOperation"]
-
-    _result_type: QuantumType = pydantic.PrivateAttr(default_factory=QuantumBit)
-
-    @property
-    def wiring_inouts(
-        self,
-    ) -> Mapping[str, ConcreteHandleBinding]:
-        inouts = {self.result_name(): self.result_var}
-        if len(self.var_handles) == 1:
-            inouts[AMPLITUDE_IO_NAME] = self.var_handles[0]
-        return inouts
-
-    @property
-    def readable_inouts(self) -> Sequence[HandleMetadata]:
-        inouts = [
-            HandleMetadata(
-                handle=self.result_var,
-                readable_location="on the left-hand side of an in-place assignment",
-            )
-        ]
-        if len(self.var_handles) == 1:
-            inouts.append(
-                HandleMetadata(
-                    handle=self.var_handles[0],
-                    readable_location="in an expression",
-                )
-            )
-        return inouts
-
-    @property
-    def wiring_outputs(self) -> Mapping[str, HandleBinding]:
-        return {}
-
-    def initialize_var_types(
-        self,
-        var_types: dict[str, QuantumType],
-        machine_precision: int,
-    ) -> None:
-        if len(var_types) != 1:
-            raise ClassiqValueError(MULTI_VARS_UNSUPPORTED_ERROR)
-        var_type = list(var_types.values())[0]
-        if not isinstance(var_type, QuantumNumeric):
-            raise ClassiqValueError(VAR_TYPE_ILLEGAL)
-        super().initialize_var_types(var_types, machine_precision)
-
-    @classmethod
-    def result_name(cls) -> str:
-        return TARGET_OUTPUT_NAME

classiq/open_library/functions/modular_exponentiation.py

@@ -1,272 +0,0 @@
-from classiq.open_library.functions.qft_functions import qft, qft_no_swap
-from classiq.qmod.builtins.classical_functions import qft_const_adder_phase
-from classiq.qmod.builtins.functions.allocation import free
-from classiq.qmod.builtins.functions.standard_gates import PHASE, SWAP, X
-from classiq.qmod.builtins.operations import (
-    allocate,
-    bind,
-    control,
-    invert,
-    repeat,
-    skip_control,
-    within_apply,
-)
-from classiq.qmod.cparam import CInt
-from classiq.qmod.qfunc import qfunc, qperm
-from classiq.qmod.qmod_variable import Const, QArray, QBit
-from classiq.qmod.symbolic import min, mod_inverse
-
-
-@qfunc
-def _check_msb(ref: CInt, x: QArray[QBit], aux: QBit) -> None:
-    within_apply(
-        lambda: invert(lambda: qft_no_swap(x)),
-        lambda: control(x[0] == ref, lambda: X(aux)),
-    )
-
-
-@qfunc
-def qft_space_add_const(value: CInt, phi_b: QArray[QBit]) -> None:
-    """
-    [Qmod Classiq-library function]
-
-    Adds a constant to a quantum number (in the Fourier space) using the Quantum Fourier Transform (QFT) Adder algorithm.
-    Assuming that the input `phi_b` has `n` qubits, the result will be $\\phi_b+=value \\mod 2^n$.
-
-    To perform the full algorithm, use:
-    within_apply(lambda: QFT(phi_b), qft_space_add_const(value, phi_b))
-
-    Args:
-        value: The constant to add to the quantum number.
-        phi_b: The quantum number (at the aft space) to which the constant is added.
-
-    """
-    repeat(
-        count=phi_b.len,
-        iteration=lambda index: PHASE(
-            theta=qft_const_adder_phase(
-                index, value, phi_b.len  # type:ignore[arg-type]
-            ),
-            target=phi_b[index],
-        ),
-    )
-
-
-@qperm(disable_perm_check=True)
-def cc_modular_add(
-    n: CInt, a: CInt, phi_b: QArray[QBit], c1: Const[QBit], c2: Const[QBit]
-) -> None:
-    """
-    [Qmod Classiq-library function]
-
-    Adds a constant `a` to a quantum number `phi_b` modulo the constant `n`, controlled by 2 qubits.
-    The quantum number `phi_b` and the constant `a` are assumed to be in the QFT space.
-
-    Args:
-        n: The modulo number.
-        a: The constant to add to the quantum number.
-        phi_b: The quantum number to which the constant is added.
-        c1: a control qubit.
-        c2: a control qubit.
-
-    """
-    ctrl: QArray[QBit] = QArray()
-    aux = QBit()
-
-    allocate(aux)
-    within_apply(
-        lambda: bind([c1, c2], ctrl),
-        lambda: (
-            control(ctrl, lambda: qft_space_add_const(a, phi_b)),
-            invert(lambda: qft_space_add_const(n, phi_b)),
-            _check_msb(1, phi_b, aux),
-            control(aux, lambda: qft_space_add_const(n, phi_b)),
-            within_apply(
-                lambda: invert(
-                    lambda: control(ctrl, lambda: qft_space_add_const(a, phi_b))
-                ),
-                lambda: _check_msb(0, phi_b, aux),
-            ),
-        ),
-    )
-    free(aux)
-
-
-@qperm(disable_perm_check=True)
-def c_modular_multiply(
-    n: CInt,
-    a: CInt,
-    b: QArray[QBit],
-    x: Const[QArray[QBit]],
-    ctrl: Const[QBit],
-) -> None:
-    """
-    [Qmod Classiq-library function]
-
-    Performs out-of-place multiplication of a quantum number `x` by a classical number `a` modulo classical number `n`,
-    controlled by a quantum bit `ctrl` and adds the result to a quantum array `b`. Applies $b += xa \\mod n$ if `ctrl=1`, and the identity otherwise.
-
-    Args:
-        n: The modulo number. Should be non-negative.
-        a: The classical factor. Should be non-negative.
-        b: The quantum number added to the multiplication result. Stores the result of the multiplication.
-        x: The quantum factor.
-        ctrl: The control bit.
-    """
-    within_apply(
-        lambda: qft(b),
-        lambda: repeat(
-            count=x.len,
-            iteration=lambda index: cc_modular_add(
-                n, (a * (2**index)) % n, b, x[index], ctrl
-            ),
-        ),
-    )
-
-
-@qperm
-def multiswap(x: QArray[QBit], y: QArray[QBit]) -> None:
-    """
-    [Qmod Classiq-library function]
-
-    Swaps the qubit states between two arrays.
-    Qubits of respective indices are swapped, and additional qubits in the longer array are left unchanged.
-
-    Args:
-        x: The first array
-        y: The second array
-
-    """
-    repeat(
-        count=min(x.len, y.len),
-        iteration=lambda index: SWAP(x[index], y[index]),
-    )
-
-
-@qfunc
-def inplace_c_modular_multiply(n: CInt, a: CInt, x: QArray[QBit], ctrl: QBit) -> None:
-    """
-    [Qmod Classiq-library function]
-
-    Performs multiplication of a quantum number `x` by a classical number `a` modulo classical number `n`,
-    controlled by a quantum bit `ctrl`. Applies $x=xa \\mod n$ if `ctrl=1`, and the identity otherwise.
-
-    Args:
-        n: The modulo number. Should be non-negative.
-        a: The classical factor. Should be non-negative.
-        x: The quantum factor.
-        ctrl: The control bit.
-    """
-    b: QArray[QBit] = QArray(length=x.len + 1)
-    allocate(b)
-    c_modular_multiply(n, a, b, x, ctrl)
-    control(ctrl, lambda: multiswap(x, b))
-    invert(lambda: c_modular_multiply(n, mod_inverse(a, n), b, x, ctrl))
-    free(b)
-
-
-@qperm(disable_perm_check=True)
-def modular_add_qft_space(n: CInt, a: CInt, phi_b: QArray[QBit]) -> None:
-    """
-    [Qmod Classiq-library function]
-
-    Adds a constant `a` to a quantum number `phi_b` modulo the constant `n`.
-    The quantum number `phi_b` is assumed to be in the QFT space.
-
-    Args:
-        n: The modulo number.
-        a: The constant to add to the quantum number.
-        phi_b: The quantum number to which the constant is added.
-
-    """
-    aux = QBit()
-
-    allocate(aux)
-    qft_space_add_const(a, phi_b),
-    skip_control(
-        lambda: (
-            invert(lambda: qft_space_add_const(n, phi_b)),
-            _check_msb(1, phi_b, aux),
-            control(aux, lambda: qft_space_add_const(n, phi_b)),
-        )
-    )
-    invert(lambda: qft_space_add_const(a, phi_b))
-    skip_control(lambda: _check_msb(0, phi_b, aux))
-    qft_space_add_const(a, phi_b)
-    free(aux)
-
-
-@qperm(disable_perm_check=True)
-def modular_multiply(
-    n: CInt,
-    a: CInt,
-    b: QArray[QBit],
-    x: Const[QArray[QBit]],
-) -> None:
-    """
-    [Qmod Classiq-library function]
-
-    Performs out-of-place multiplication of a quantum number `x` by a classical number `a` modulo classical number `n`,
-    and adds the result to a quantum array `b` (Applies $b += xa \\mod n$).
-
-    Args:
-        n: The modulo number. Should be non-negative.
-        a: The classical factor. Should be non-negative.
-        b: The quantum number added to the multiplication result. Stores the result of the multiplication.
-        x: The quantum factor.
-    """
-    within_apply(
-        lambda: qft(b),
-        lambda: repeat(
-            count=x.len,
-            iteration=lambda index: control(
-                x[index], lambda: modular_add_qft_space(n, (a * (2**index)) % n, b)
-            ),
-        ),
-    )
-
-
-@qfunc
-def inplace_modular_multiply(n: CInt, a: CInt, x: QArray[QBit]) -> None:
-    """
-    [Qmod Classiq-library function]
-
-    Performs multiplication of a quantum number `x` by a classical number `a` modulo classical number `n`
-    (Applies $x=xa \\mod n$).
-
-    Args:
-        n: The modulo number. Should be non-negative.
-        a: The classical factor. Should be non-negative.
-        x: The quantum factor.
-
-    Comment: It is assumed that `a` has an inverse modulo `n`
-    """
-    b: QArray[QBit] = QArray(length=x.len + 1)
-    allocate(b)
-    modular_multiply(n, a, b, x)
-    multiswap(x, b)
-    invert(lambda: modular_multiply(n, mod_inverse(a, n), b, x))
-    free(b)
-
-
-@qfunc
-def modular_exp(n: CInt, a: CInt, x: QArray[QBit], power: QArray[QBit]) -> None:
-    """
-    [Qmod Classiq-library function]
-
-    Raises a classical integer `a` to the power of a quantum number `power` modulo classical integer `n`
-    times a quantum number `x`. Performs $x=(a^{power} \\mod n)*x$ in-place.
-    (and specifically if at the input $x=1$, at the output $x=a^{power} \\mod n$).
-
-    Args:
-        n: The modulus number. Should be non-negative.
-        a: The base of the exponentiation. Should be non-negative.
-        x: A quantum number that multiplies the modular exponentiation and holds the output. It should be at least the size of $\\lceil \\log(n) \rceil$.
-        power: The power of the exponentiation.
-    """
-    repeat(
-        count=power.len,
-        iteration=lambda index: inplace_c_modular_multiply(
-            n, (a ** (2**index)) % n, x, power[index]
-        ),
-    )