oqubit 0.1__py3-none-any.whl

oqubit/__init__.py

@@ -0,0 +1,47 @@
+from .core.qubit import Qubit
+from .core.statevector import StateVector
+from .core.operators import Operator, Gate
+from .gates.single import X,Y,Z,H,S,T,SX
+from .gates.controlled import CX,CY,CZ,CS,CH,CT,CSX
+from .gates.multi import SWAP,ISWAP,SQRT_SWAP,CCX,CSWAP
+from .measurement.measurement import measure
+from .measurement.sampling import sample
+from .circuit.circuit import Circuit
+from .circuit.instruction import Instruction
+from .algorithms.deutsch import deutsch
+from .algorithms.deutsch_jozsa import deutsch_jozsa
+from .algorithms.bernstein_vazirani import bernstein_vazirani
+from .algorithms.superdense_coding import encode,decode
+__all__=["Qubit",
+         "StateVector",
+         "Operator",
+         "Gate",
+         "X",
+         "Y",
+         "Z",
+         "H",
+         "S",
+         "T",
+         "SX",
+         "CX",
+         "CY",
+         "CZ",
+         "CS",
+         "CH",
+         "CT",
+         "CSX",
+         "SWAP",
+         "ISWAP",
+         "SQRT_SWAP",
+         "CCX",
+         "CSWAP",
+         "measure",
+         "sample",
+         "Circuit",
+         "Instruction",
+         "deutsch",
+         "deutsch_jozsa",
+         "bernstein_vazirani",
+         "encode",
+         "decode",
+         ]

oqubit/algorithms/__init__.py

@@ -0,0 +1,5 @@
+from .deutsch import deutsch
+from .deutsch_jozsa import deutsch_jozsa
+from .bernstein_vazirani import bernstein_vazirani
+from .superdense_coding import encode,decode
+__all__=["deutsch","deutsch_jozsa","bernstein_vazirani","encode","decode",]

oqubit/algorithms/bernstein_vazirani.py

@@ -0,0 +1,60 @@
+"""
+Bernstein–Vazirani algorithm.
+
+This module implements the Bernstein–Vazirani algorithm for recovering
+a hidden binary string ``s`` from a Boolean function of the form
+
+    f(x) = s · x (mod 2)
+
+where ``s`` and ``x`` are binary strings of equal length.
+
+The algorithm determines the complete hidden string using a single
+quantum-oracle evaluation.
+
+Notes
+-----
+The implementation constructs the oracle from elementary X and
+controlled-X gates. The oracle therefore represents the transformation
+
+    U_f |x>|y> = |x>|y XOR f(x)>.
+
+The first ``n`` qubits form the input register and the final qubit
+is the oracle ancilla.
+
+For a secret string
+
+    s = s_0 s_1 ... s_(n-1),
+
+the oracle applies a controlled-X gate from input qubit ``i`` to the
+ancilla whenever ``s_i == 1``.
+"""
+from __future__ import annotations
+from typing import Final
+from ..circuit import Circuit
+__all__ = ["bernstein_vazirani"]
+def _validate_secret(secret: str) -> None:
+    if not isinstance(secret, str):
+        raise TypeError("secret must be a string.")
+    if not secret:
+        raise ValueError("secret must not be empty.")
+    if any(bit not in "01" for bit in secret):
+        raise ValueError("secret must contain only binary digits '0' and '1'.")
+def _apply_oracle(circuit: Circuit,secret: str,) -> None:
+    ancilla = len(secret)
+    for qubit, bit in enumerate(secret):
+        if bit == "1":
+            circuit.cx(qubit, ancilla)
+def bernstein_vazirani(secret: str) -> str:
+    _validate_secret(secret)
+    num_qubits = len(secret)
+    ancilla = num_qubits
+    circuit = Circuit(num_qubits + 1)
+    circuit.x(ancilla)
+    for qubit in range(num_qubits + 1):
+        circuit.h(qubit)
+    _apply_oracle(circuit,secret,)
+    for qubit in range(num_qubits):
+        circuit.h(qubit)
+    state = circuit.run()
+    result = circuit.measure(state=state,qubits=tuple(range(num_qubits)),)
+    return "".join(str(bit) for bit in result)

oqubit/algorithms/deutsch.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Literal
+from ..circuit import Circuit
+__all__ = ["deutsch"]
+DeutschResult = Literal["constant", "balanced"]
+def _validate_function(function: Callable[[int], int],) -> tuple[int, int]:
+    if not callable(function):
+        raise TypeError("function must be callable.")
+    f0 = function(0)
+    f1 = function(1)
+    if f0 not in (0, 1) or f1 not in (0, 1):
+        raise ValueError("function must return either 0 or 1.")
+    return f0, f1
+def _apply_oracle(circuit: Circuit,f0: int,f1: int,) -> None:
+    if f0 == 0 and f1 == 0:
+        return
+    if f0 == 1 and f1 == 1:
+        circuit.x(1)
+        return
+    if f0 == 0 and f1 == 1:
+        circuit.cx(0, 1)
+        return
+    circuit.x(1)
+    circuit.cx(0, 1)
+    circuit.x(1)
+def deutsch(function: Callable[[int], int],) -> DeutschResult:
+    f0, f1 = _validate_function(function)
+    circuit = Circuit(2)
+    circuit.x(1)
+    circuit.h(0)
+    circuit.h(1)
+    _apply_oracle(circuit, f0, f1)
+    circuit.h(0)
+    state = circuit.run()
+    result = circuit.measure(state=state,qubits=0,)
+    return "constant" if result == 0 else "balanced"

oqubit/algorithms/deutsch_joza.py

@@ -0,0 +1,121 @@
+"""
+Deutsch–Jozsa algorithm.
+
+This module implements the Deutsch–Jozsa algorithm for Boolean
+functions of the form
+
+    f : {0, 1}^n -> {0, 1}
+
+under the promise that ``f`` is either constant or balanced.
+
+The algorithm determines whether the function is constant or
+balanced using a single quantum-oracle evaluation.
+
+Notes
+-----
+The implementation constructs the oracle from elementary X and
+controlled-X gates. The oracle therefore represents the transformation
+
+    U_f |x>|y> = |x>|y XOR f(x)>.
+
+The first ``n`` qubits form the input register and the final qubit
+is the oracle ancilla.
+"""
+from __future__ import annotations
+from collections.abc import Callable, Iterable
+from itertools import product
+from typing import Literal
+from ..circuit import Circuit
+__all__ = ["deutsch_jozsa"]
+DeutschJozsaResult = Literal["constant", "balanced"]
+def _validate_num_qubits(num_qubits: int) -> None:
+    if not isinstance(num_qubits, int):
+        raise TypeError("num_qubits must be an integer.")
+    if isinstance(num_qubits, bool):
+        raise TypeError("num_qubits must be an integer.")
+    if num_qubits < 1:
+        raise ValueError("num_qubits must be at least 1.")
+def _validate_function(function: Callable[[tuple[int, ...]], int],num_qubits: int,) -> dict[tuple[int, ...], int]:
+    if not callable(function):
+        raise TypeError("function must be callable.")
+    truth_table: dict[tuple[int, ...], int] = {}
+    for bits in product((0, 1), repeat=num_qubits):
+        value = function(bits)
+        if not isinstance(value, int) or isinstance(value, bool):
+            raise TypeError("function must return an integer value of 0 or 1.")
+        if value not in (0, 1):
+            raise ValueError("function must return either 0 or 1.")
+        truth_table[bits] = value
+    return truth_table
+def _classify_truth_table(truth_table: dict[tuple[int, ...], int],) -> DeutschJozsaResult:
+    values = tuple(truth_table.values())
+    total = len(values)
+    ones = sum(values)
+    if ones == 0 or ones == total:
+        return "constant"
+    if ones * 2 == total:
+        return "balanced"
+    raise ValueError("function must be either constant or balanced.")
+def _apply_oracle(circuit: Circuit,truth_table: dict[tuple[int, ...], int],num_qubits: int,) -> None:
+    ancilla = num_qubits
+    for bits, value in truth_table.items():
+        if value == 0:
+            continue
+        if num_qubits == 1:
+            if bits[0] == 1:
+                circuit.cx(0, ancilla)
+            else:
+                circuit.x(0)
+                circuit.cx(0, ancilla)
+                circuit.x(0)
+            continue
+        if num_qubits == 2:
+            _apply_two_controlled_x(
+                circuit,
+                bits,
+                ancilla,
+            )
+            continue
+        raise NotImplementedError(
+            "Deutsch–Jozsa oracles with more than 2 input qubits "
+            "require multi-controlled gates, which are not yet "
+            "exposed by the current OQubit Circuit API."
+        )
+def _apply_two_controlled_x(circuit: Circuit,bits: tuple[int, ...],target: int,) -> None:
+    control0 = 0
+    control1 = 1
+    zero_controls = [
+        index
+        for index, bit in enumerate(bits)
+        if bit == 0
+        ]
+    for qubit in zero_controls:
+        circuit.x(qubit)
+    circuit.ccx(control0,control1,target,)
+    for qubit in reversed(zero_controls):
+        circuit.x(qubit)
+def deutsch_jozsa(function: Callable[[tuple[int, ...]], int],num_qubits: int,) -> DeutschJozsaResult:
+    _validate_num_qubits(num_qubits)
+    truth_table = _validate_function(function,num_qubits,)
+    _classify_truth_table(truth_table)
+    circuit = Circuit(num_qubits + 1)
+    ancilla = num_qubits
+    circuit.x(ancilla)
+    for qubit in range(num_qubits + 1):
+        circuit.h(qubit)
+    _apply_oracle(
+        circuit,
+        truth_table,
+        num_qubits,
+    )
+    for qubit in range(num_qubits):
+        circuit.h(qubit)
+    state = circuit.run()
+    result = circuit.measure(
+        state=state,
+        qubits=tuple(range(num_qubits)),
+    )
+
+    if all(bit == 0 for bit in result):
+        return "constant"
+    return "balanced"

oqubit/algorithms/deutsch_jozsa.py

@@ -0,0 +1,121 @@
+"""
+Deutsch–Jozsa algorithm.
+
+This module implements the Deutsch–Jozsa algorithm for Boolean
+functions of the form
+
+    f : {0, 1}^n -> {0, 1}
+
+under the promise that ``f`` is either constant or balanced.
+
+The algorithm determines whether the function is constant or
+balanced using a single quantum-oracle evaluation.
+
+Notes
+-----
+The implementation constructs the oracle from elementary X and
+controlled-X gates. The oracle therefore represents the transformation
+
+    U_f |x>|y> = |x>|y XOR f(x)>.
+
+The first ``n`` qubits form the input register and the final qubit
+is the oracle ancilla.
+"""
+from __future__ import annotations
+from collections.abc import Callable, Iterable
+from itertools import product
+from typing import Literal
+from ..circuit import Circuit
+__all__ = ["deutsch_jozsa"]
+DeutschJozsaResult = Literal["constant", "balanced"]
+def _validate_num_qubits(num_qubits: int) -> None:
+    if not isinstance(num_qubits, int):
+        raise TypeError("num_qubits must be an integer.")
+    if isinstance(num_qubits, bool):
+        raise TypeError("num_qubits must be an integer.")
+    if num_qubits < 1:
+        raise ValueError("num_qubits must be at least 1.")
+def _validate_function(function: Callable[[tuple[int, ...]], int],num_qubits: int,) -> dict[tuple[int, ...], int]:
+    if not callable(function):
+        raise TypeError("function must be callable.")
+    truth_table: dict[tuple[int, ...], int] = {}
+    for bits in product((0, 1), repeat=num_qubits):
+        value = function(bits)
+        if not isinstance(value, int) or isinstance(value, bool):
+            raise TypeError("function must return an integer value of 0 or 1.")
+        if value not in (0, 1):
+            raise ValueError("function must return either 0 or 1.")
+        truth_table[bits] = value
+    return truth_table
+def _classify_truth_table(truth_table: dict[tuple[int, ...], int],) -> DeutschJozsaResult:
+    values = tuple(truth_table.values())
+    total = len(values)
+    ones = sum(values)
+    if ones == 0 or ones == total:
+        return "constant"
+    if ones * 2 == total:
+        return "balanced"
+    raise ValueError("function must be either constant or balanced.")
+def _apply_oracle(circuit: Circuit,truth_table: dict[tuple[int, ...], int],num_qubits: int,) -> None:
+    ancilla = num_qubits
+    for bits, value in truth_table.items():
+        if value == 0:
+            continue
+        if num_qubits == 1:
+            if bits[0] == 1:
+                circuit.cx(0, ancilla)
+            else:
+                circuit.x(0)
+                circuit.cx(0, ancilla)
+                circuit.x(0)
+            continue
+        if num_qubits == 2:
+            _apply_two_controlled_x(
+                circuit,
+                bits,
+                ancilla,
+            )
+            continue
+        raise NotImplementedError(
+            "Deutsch–Jozsa oracles with more than 2 input qubits "
+            "require multi-controlled gates, which are not yet "
+            "exposed by the current OQubit Circuit API."
+        )
+def _apply_two_controlled_x(circuit: Circuit,bits: tuple[int, ...],target: int,) -> None:
+    control0 = 0
+    control1 = 1
+    zero_controls = [
+        index
+        for index, bit in enumerate(bits)
+        if bit == 0
+        ]
+    for qubit in zero_controls:
+        circuit.x(qubit)
+    circuit.ccx(control0,control1,target,)
+    for qubit in reversed(zero_controls):
+        circuit.x(qubit)
+def deutsch_jozsa(function: Callable[[tuple[int, ...]], int],num_qubits: int,) -> DeutschJozsaResult:
+    _validate_num_qubits(num_qubits)
+    truth_table = _validate_function(function,num_qubits,)
+    _classify_truth_table(truth_table)
+    circuit = Circuit(num_qubits + 1)
+    ancilla = num_qubits
+    circuit.x(ancilla)
+    for qubit in range(num_qubits + 1):
+        circuit.h(qubit)
+    _apply_oracle(
+        circuit,
+        truth_table,
+        num_qubits,
+    )
+    for qubit in range(num_qubits):
+        circuit.h(qubit)
+    state = circuit.run()
+    result = circuit.measure(
+        state=state,
+        qubits=tuple(range(num_qubits)),
+    )
+
+    if result==0:
+        return "constant"
+    return "balanced"

oqubit/algorithms/qft.py

@@ -0,0 +1,87 @@
+"""
+Quantum Fourier Transform (QFT).
+
+This module provides a circuit-level implementation of the Quantum
+Fourier Transform.
+
+The QFT on n qubits is defined as:
+
+    |x> -> 1 / sqrt(2^n) * sum_y exp(2πixy / 2^n) |y>
+
+The implementation uses:
+    - Hadamard gates
+    - Controlled phase rotations
+    - SWAP gates for final bit reversal
+
+Notes
+-----
+The QFT is implemented as a circuit transformation. It does not
+directly manipulate state vectors or simulator internals.
+
+Examples
+--------
+>>> from oqubit.circuit import Circuit
+>>> from oqubit.algorithms.qft import qft
+
+>>> circuit = Circuit(3)
+>>> qft(circuit)
+
+The resulting circuit contains the QFT operation on all three qubits.
+
+A subset of qubits can also be transformed:
+
+>>> circuit = Circuit(5)
+>>> qft(circuit, qubits=[1, 2, 3])
+"""
+from __future__ import annotations
+import math
+from collections.abc import Sequence
+from oqubit.circuit import Circuit
+from oqubit.gates import H, SWAP
+from oqubit.gates.controlled import ControlledPhase
+__all__ = ["qft"]
+
+def qft(
+    circuit: Circuit,
+    qubits: Sequence[int] | None = None,
+) -> Circuit:
+    if not isinstance(circuit, Circuit):
+        raise TypeError("circuit must be an instance of Circuit.")
+    if qubits is None:
+        qubit_indices = list(range(circuit.num_qubits))
+    else:
+        if isinstance(qubits, (str, bytes)):
+            raise TypeError("qubits must be a sequence of integers.")
+        qubit_indices = list(qubits)
+        if not all(isinstance(q, int) for q in qubit_indices):
+            raise TypeError("qubits must contain only integers.")
+    if not qubit_indices:
+        raise ValueError("QFT requires at least one qubit.")
+    if len(set(qubit_indices)) != len(qubit_indices):
+        raise ValueError("QFT qubit indices must be unique.")
+    for qubit in qubit_indices:
+        if qubit < 0 or qubit >= circuit.num_qubits:
+            raise ValueError(
+                f"Qubit index {qubit} is outside the circuit."
+            )
+    n = len(qubit_indices)
+    for j in range(n):
+        target = qubit_indices[j]
+        circuit.add(H, target)
+        for k in range(2, n - j + 1):
+            control = qubit_indices[j + k - 1]
+            angle = 2.0 * math.pi / (2**k)
+            circuit.add(
+                ControlledPhase(angle),
+                control,
+                target,
+            )
+    for i in range(n // 2):
+        circuit.add(
+            SWAP,
+            qubit_indices[i],
+            qubit_indices[n - i - 1],
+        )
+
+    return circuit
+

oqubit/algorithms/superdense_coding.py

@@ -0,0 +1,28 @@
+"""
+Superdense Coding algorithm.
+
+Superdense coding transmits two classical bits using one qubit
+and a previously shared entangled Bell pair.
+"""
+from ..circuit import Circuit
+__all__ = ["encode", "decode"]
+def encode(bit0, bit1):
+    if bit0 not in (0, 1):
+        raise ValueError("bit0 must be 0 or 1.")
+    if bit1 not in (0, 1):
+        raise ValueError("bit1 must be 0 or 1.")
+    circuit = Circuit(2)
+    circuit.h(0)
+    circuit.cx(0, 1)
+    if bit1:
+        circuit.x(0)
+    if bit0:
+        circuit.z(0)
+    return circuit
+def decode(circuit):
+    if not isinstance(circuit, Circuit):
+        raise TypeError("circuit must be an OQubit Circuit.")
+    circuit.cx(0, 1)
+    circuit.h(0)
+    state = circuit.run()
+    return circuit.measure(state=state,qubits=(0, 1),)

oqubit/circuit/__init__.py

@@ -0,0 +1,3 @@
+from .circuit import Circuit
+from .instruction import Instruction
+__all__=["Circuit","Instruction"]