oqubit 0.1__py3-none-any.whl

oqubit/circuit/circuit.py

@@ -0,0 +1,278 @@
+from ..core.operators import Gate
+from ..core.statevector import StateVector
+from ..core.qubit import Qubit
+from ..measurement import measure, sample
+from .instruction import Instruction
+class Circuit:
+    """
+    Represents a quantum circuit.
+
+    Parameters
+    ----------
+    num_qubits : int
+        Number of qubits in the circuit.
+    """
+    def __init__(self, num_qubits):
+        if not isinstance(num_qubits, int):
+            raise TypeError("num_qubits must be an integer.")
+        if num_qubits < 1:
+            raise ValueError("num_qubits must be at least 1.")
+        self.num_qubits = num_qubits
+        self.instructions = []
+    def _validate_qubit(self, qubit):
+        if not isinstance(qubit, int):
+            raise TypeError("Qubit index must be an integer.")
+        if qubit < 0 or qubit >= self.num_qubits:
+            raise IndexError(
+                f"Qubit index {qubit} is out of range for "
+                f"{self.num_qubits} qubits."
+            )
+    def _validate_qubits(self, qubits):
+        for qubit in qubits:
+            self._validate_qubit(qubit)
+    def _add_instruction(self, gate, controls=None, targets=None):
+        instruction = Instruction(
+            gate=gate,
+            controls=controls,
+            targets=targets,
+        )
+        self._validate_qubits(instruction.qubits)
+        self.instructions.append(instruction)
+        return self
+    def append(self, gate, controls=None, targets=None):
+        return self._add_instruction(
+            gate,
+            controls=controls,
+            targets=targets,
+        )
+    def x(self, qubit):
+        from ..gates.single import X
+
+        return self._add_instruction(
+            X,
+            targets=qubit,
+        )
+
+    def y(self, qubit):
+        from ..gates.single import Y
+
+        return self._add_instruction(
+            Y,
+            targets=qubit,
+        )
+
+    def z(self, qubit):
+        from ..gates.single import Z
+
+        return self._add_instruction(
+            Z,
+            targets=qubit,
+        )
+
+    def h(self, qubit):
+        from ..gates.single import H
+
+        return self._add_instruction(
+            H,
+            targets=qubit,
+        )
+
+    def s(self, qubit):
+        from ..gates.single import S
+
+        return self._add_instruction(
+            S,
+            targets=qubit,
+        )
+
+    def t(self, qubit):
+        from ..gates.single import T
+
+        return self._add_instruction(
+            T,
+            targets=qubit,
+        )
+
+    def sx(self, qubit):
+        from ..gates.single import SX
+
+        return self._add_instruction(
+            SX,
+            targets=qubit,
+        )
+    def cx(self, control, target):
+        from ..gates.controlled import CX
+
+        return self._add_instruction(
+            CX,
+            controls=control,
+            targets=target,
+        )
+
+    def cy(self, control, target):
+        from ..gates.controlled import CY
+
+        return self._add_instruction(
+            CY,
+            controls=control,
+            targets=target,
+        )
+
+    def cz(self, control, target):
+        from ..gates.controlled import CZ
+
+        return self._add_instruction(
+            CZ,
+            controls=control,
+            targets=target,
+        )
+
+    def ch(self, control, target):
+        from ..gates.controlled import CH
+
+        return self._add_instruction(
+            CH,
+            controls=control,
+            targets=target,
+        )
+
+    def cs(self, control, target):
+        from ..gates.controlled import CS
+
+        return self._add_instruction(
+            CS,
+            controls=control,
+            targets=target,
+        )
+
+    def ct(self, control, target):
+        from ..gates.controlled import CT
+
+        return self._add_instruction(
+            CT,
+            controls=control,
+            targets=target,
+        )
+
+    def csx(self, control, target):
+        from ..gates.controlled import CSX
+
+        return self._add_instruction(
+            CSX,
+            controls=control,
+            targets=target,
+        )
+    def swap(self, qubit1, qubit2):
+        from ..gates.multi import SWAP
+
+        return self._add_instruction(
+            SWAP,
+            targets=[qubit1, qubit2],
+        )
+
+    def iswap(self, qubit1, qubit2):
+        from ..gates.multi import ISWAP
+
+        return self._add_instruction(
+            ISWAP,
+            targets=[qubit1, qubit2],
+        )
+
+    def sqrt_swap(self, qubit1, qubit2):
+        from ..gates.multi import SQRT_SWAP
+
+        return self._add_instruction(
+            SQRT_SWAP,
+            targets=[qubit1, qubit2],
+        )
+
+    def ccx(self, control1, control2, target):
+        from ..gates.multi import CCX
+
+        return self._add_instruction(
+            CCX,
+            controls=[control1, control2],
+            targets=target,
+        )
+
+    def cswap(self, control, target1, target2):
+        from ..gates.multi import CSWAP
+
+        return self._add_instruction(
+            CSWAP,
+            controls=control,
+            targets=[target1, target2],
+        )
+    def initial_state(self):
+        qubits = [
+            Qubit.zero()
+            for _ in range(self.num_qubits)
+        ]
+
+        return StateVector(qubits)
+
+    def run(self, state=None):
+        if state is None:
+            state = self.initial_state()
+
+        if not isinstance(state, StateVector):
+            raise TypeError("state must be a StateVector.")
+
+        if state.num_qubits != self.num_qubits:
+            raise ValueError(
+                f"Circuit requires {self.num_qubits} qubits, "
+                f"but state contains {state.num_qubits}."
+            )
+
+        for instruction in self.instructions:
+            state.apply(
+                instruction.gate,
+                controls=instruction.controls,
+                targets=instruction.targets,
+            )
+
+        return state
+    def measure(self, state=None, qubits=None):
+        if state is None:
+            state = self.run()
+
+        return measure(
+            state,
+            qubits=qubits,
+        )
+
+    def sample(self, shots=1024, state=None, qubits=None):
+        if state is None:
+            state = self.run()
+
+        return sample(
+            state,
+            shots=shots,
+            qubits=qubits,
+        )
+    @property
+    def depth(self):
+        return len(self.instructions)
+    @property
+    def notation(self):
+        return self.run().notation
+    @property
+    def size(self):
+        return len(self.instructions)
+    def clear(self):
+        self.instructions.clear()
+        return self
+    def __repr__(self):
+        return (
+            f"Circuit("
+            f"num_qubits={self.num_qubits}, "
+            f"instructions={len(self.instructions)})"
+        )
+    def __len__(self):
+        return len(self.instructions)
+    def __str__(self):
+        return "\n".join(
+            str(instruction)
+            for instruction in self.instructions
+        )
+__all__ = ["Circuit"]

oqubit/circuit/instruction.py

@@ -0,0 +1,64 @@
+from ..core.operators import Gate
+class Instruction:
+    """
+    Represents a single gate operation in a quantum circuit.
+
+    Parameters
+    ----------
+    gate : Gate
+        Gate to apply.
+    controls : int | list[int] | None
+        Control qubit index or indices.
+    targets : int | list[int] | None
+        Target qubit index or indices.
+    """
+
+    def __init__(self, gate, controls=None, targets=None):
+        if not isinstance(gate, Gate):
+            raise TypeError("gate must be a Gate object.")
+
+        self.gate = gate
+        self.controls = self._normalize_qubits(controls)
+        self.targets = self._normalize_qubits(targets)
+
+        if len(self.controls) != gate.num_controls:
+            raise ValueError(
+                f"{gate.name} requires {gate.num_controls} control qubit(s), "
+                f"got {len(self.controls)}."
+            )
+
+        if len(self.targets) != gate.num_targets:
+            raise ValueError(
+                f"{gate.name} requires {gate.num_targets} target qubit(s), "
+                f"got {len(self.targets)}."
+            )
+
+        qubits = self.controls + self.targets
+
+        if len(set(qubits)) != len(qubits):
+            raise ValueError(
+                "A qubit cannot be used more than once in the same instruction."
+            )
+
+    @staticmethod
+    def _normalize_qubits(qubits):
+        if qubits is None:
+            return []
+
+        if isinstance(qubits, int):
+            return [qubits]
+
+        return list(qubits)
+
+    @property
+    def qubits(self):
+        return self.controls + self.targets
+
+    def __repr__(self):
+        return (
+            f"Instruction("
+            f"gate={self.gate.name!r}, "
+            f"controls={self.controls}, "
+            f"targets={self.targets})"
+        )
+__all__ = ["Instruction"]

oqubit/core/__init__.py

@@ -0,0 +1,4 @@
+from .qubit import Qubit
+from .statevector import StateVector
+from .operators import Operator
+__all__ = ["Qubit","StateVector","Operator","Gate"]

oqubit/core/operators.py

@@ -0,0 +1,79 @@
+"""
+Core operator definitions for OQubit.
+
+This module provides the base Operator class for linear operators
+and the Gate class for quantum gates.
+"""
+import numpy as np
+class Operator:
+    """
+    Represents a linear operator acting on a quantum state.
+
+    Parameters
+    ----------
+    matrix : array-like
+        Square matrix representing the operator.
+    """
+
+    def __init__(self, matrix):
+        self.matrix = np.asarray(matrix, dtype=complex)
+        if self.matrix.ndim != 2:
+            raise ValueError("Operator matrix must be two-dimensional.")
+        if self.matrix.shape[0] != self.matrix.shape[1]:
+            raise ValueError("Operator matrix must be square.")
+    @property
+    def dimension(self):
+        """Return the dimension of the operator."""
+        return self.matrix.shape[0]
+    def __matmul__(self, other):
+        """Apply the operator using the @ operator."""
+        return self.matrix @ other
+    def __repr__(self):
+        return (f"Operator("f"dimension={self.dimension})")
+class Gate(Operator):
+    """
+    Represents a quantum gate.
+
+    A Gate is a specialized Operator that also describes
+    how many qubits it acts on and its control/target structure.
+
+    Parameters
+    ----------
+    matrix : array-like
+        Square matrix representing the quantum gate.
+
+    name : str
+        Name of the gate.
+
+    num_qubits : int
+        Number of qubits the gate acts on.
+
+    num_controls : int, default=0
+        Number of control qubits.
+
+    num_targets : int, default=0
+        Number of target qubits.
+    """
+
+    def __init__(self,matrix,name,num_qubits,num_controls=0,num_targets=0,):
+        super().__init__(matrix)
+        if not isinstance(name, str):
+            raise TypeError("Gate name must be a string.")
+        if not isinstance(num_qubits, int) or num_qubits < 1:
+            raise ValueError("num_qubits must be a positive integer.")
+        if not isinstance(num_controls, int) or num_controls < 0:
+            raise ValueError("num_controls must be a non-negative integer.")
+        if not isinstance(num_targets, int) or num_targets < 0:
+            raise ValueError("num_targets must be a non-negative integer.")
+        if num_controls + num_targets != num_qubits:
+            raise ValueError("num_controls + num_targets must equal num_qubits.")
+        expected_dimension = 2 ** num_qubits
+        if self.dimension != expected_dimension:
+            raise ValueError(f"{name} is a {num_qubits}-qubit gate, "f"so its matrix must be "f"{expected_dimension}x{expected_dimension}.")
+        self.name = name
+        self.num_qubits = num_qubits
+        self.num_controls = num_controls
+        self.num_targets = num_targets
+    def __repr__(self):
+        return (f"Gate("f"name='{self.name}', "f"num_qubits={self.num_qubits}, "f"num_controls={self.num_controls}, "f"num_targets={self.num_targets})")
+__all__ = ["Operator","Gate",]

oqubit/core/qubit.py

@@ -0,0 +1,68 @@
+import numpy as np
+class Qubit():
+    """
+Qubit represents a single-qubit quantum state of the form
+
+    |ψ⟩ = α|0⟩ + β|1⟩
+
+where alpha and beta are the probability amplitudes.
+The normalize parameter determines whether the state is
+normalized during initialization.
+"""
+    def __init__(self,alpha=1,beta=0,normalize=True):
+        self.alpha=complex(alpha)
+        self.beta=complex(beta)
+        self.normalize=normalize
+        if (normalize==True):
+            self._normalize()
+    def _normalize(self):
+        norm = np.sqrt(abs(self.alpha) ** 2 +abs(self.beta) ** 2)
+        if np.isclose(norm, 0):
+            raise ValueError("Cannot normalize zero state.")
+        self.alpha /= norm
+        self.beta /= norm
+    def apply(self, gate):
+        if gate.num_qubits!=1:
+            raise ValueError(f"{gate.name} requires {gate.num_qubits} qubits. \n""Use StateVector.apply() for multi-qubit gates.")
+        result = gate @ self.state
+        self.alpha = result[0]
+        self.beta = result[1]
+        return self
+    @classmethod
+    def i(cls):
+        return cls(1 / np.sqrt(2), 1j / np.sqrt(2))
+    @classmethod
+    def minus_i(cls):
+        return cls(1 / np.sqrt(2), -1j / np.sqrt(2))
+    @classmethod
+    def plus(cls):
+        return cls(1/np.sqrt(2), 1/np.sqrt(2))
+    @classmethod
+    def minus(cls):
+        return cls(1/np.sqrt(2),-1/np.sqrt(2))
+    @classmethod
+    def zero(cls):
+        return cls(1,0)
+    @classmethod
+    def one(cls):
+        return cls(0,1)
+    @property
+    def state(self):
+        return np.array([self.alpha,self.beta],dtype=complex)
+    @property 
+    def prob_0(self):
+        norm = np.sqrt(abs(self.alpha) ** 2 +abs(self.beta) ** 2)
+        if np.isclose(norm, 0):
+            raise ValueError("Cannot normalize zero state.")
+        alpha=abs(self.alpha)/norm
+        return (alpha)**2
+    @property
+    def prob_1(self):
+        norm = np.sqrt(abs(self.alpha) ** 2 +abs(self.beta) ** 2)
+        if np.isclose(norm, 0):
+            raise ValueError("Cannot normalize zero state.")
+        beta=abs(self.beta)/norm
+        return (beta)**2
+    def __repr__(self):
+        return f"Qubit:\t{self.alpha} |0\u27E9 \t {self.beta}|1\u27E9"
+__all__=["Qubit"]

oqubit/core/statevector.py

@@ -0,0 +1,151 @@
+import numpy as np
+from .qubit import Qubit
+from .operators import Gate
+class StateVector:
+    """
+    Represents the quantum state of an n-qubit system.
+
+    A state vector is a complex vector containing the probability
+    amplitudes of all computational basis states.
+
+    For example, a two-qubit state can be written as:
+
+        |ψ⟩ = α|00⟩ + β|01⟩ + γ|10⟩ + δ|11⟩
+
+    The amplitudes satisfy:
+
+        |α|² + |β|² + |γ|² + |δ|² = 1
+
+    for a normalized state.
+
+    Qubit ordering follows the order supplied to StateVector:
+
+        StateVector([q0, q1, q2])
+
+    corresponds to:
+
+        |q0 q1 q2⟩
+    """
+
+    def __init__(self, qubits):
+        self.qubits = list(qubits)
+        if not self.qubits:
+            raise ValueError("StateVector requires at least one qubit.")
+        if not all(isinstance(q, Qubit) for q in self.qubits):
+            raise TypeError("All elements must be Qubit objects.")
+        self._state = self._build_state()
+    def _build_state(self):
+        state = self.qubits[0].state
+        for qubit in self.qubits[1:]:
+            state = np.kron(state, qubit.state)
+        return state
+    def apply(self, gate, controls=None, targets=None):
+        if not isinstance(gate, Gate):
+            raise TypeError("gate must be a Gate object.")
+        if gate.num_qubits > self.num_qubits:
+            raise ValueError(
+                f"{gate.name} requires {gate.num_qubits} qubits, "
+                f"but the state contains only "
+                f"{self.num_qubits} qubits."
+            )
+        if controls is None:
+            controls = []
+        elif isinstance(controls, int):
+            controls = [controls]
+        else:
+            controls = list(controls)
+        if targets is None:
+            targets = []
+        elif isinstance(targets, int):
+            targets = [targets]
+        else:
+            targets = list(targets)
+        if len(controls) != gate.num_controls:
+            raise ValueError(f"{gate.name} requires "f"{gate.num_controls} control qubits, "f"but {len(controls)} were provided.")
+        if len(targets) != gate.num_targets:
+            raise ValueError(f"{gate.name} requires "f"{gate.num_targets} target qubits, "f"but {len(targets)} were provided.")
+        qubits = controls + targets
+        if len(qubits) != gate.num_qubits:
+            raise ValueError(f"{gate.name} requires "f"{gate.num_qubits} qubits.")
+        for index in qubits:
+            if not isinstance(index, int):
+                raise TypeError("Qubit indices must be integers.")
+            if index < 0 or index >= self.num_qubits:
+                raise IndexError(f"Qubit index {index} is out of range.")
+        if len(set(qubits)) != len(qubits):
+            raise ValueError("A qubit cannot be used more than once in the same gate.")
+        if gate.num_qubits == 1:
+            self._apply_single_qubit_gate(gate,targets[0])
+            return self
+        self._apply_multi_qubit_gate(gate,qubits)
+        return self
+    def _apply_single_qubit_gate(self, gate, target):
+        matrix = gate.matrix
+        step = 2 ** (self.num_qubits - target - 1)
+        block = step * 2
+        old_state = self._state.copy()
+        for start in range(0,len(old_state),block):
+            for offset in range(step):
+                i0 = start + offset
+                i1 = i0 + step
+                a = old_state[i0]
+                b = old_state[i1]
+                self._state[i0] = (matrix[0, 0] * a+ matrix[0, 1] * b)
+                self._state[i1] = (matrix[1, 0] * a+ matrix[1, 1] * b)
+    def _apply_multi_qubit_gate(self, gate, qubits):
+        n = self.num_qubits
+        k = gate.num_qubits
+        matrix = gate.matrix
+        old_state = self._state.copy()
+        new_state = np.zeros_like(old_state)
+        bit_positions = [n - qubit - 1
+            for qubit in qubits
+        ]
+        untouched_positions = [position
+            for position in range(n)
+            if position not in bit_positions
+        ]
+        for base in range(2 ** len(untouched_positions)):
+            base_index = 0
+            for i, position in enumerate(untouched_positions):
+                bit = (base >> i) & 1
+                base_index |= (bit << position)
+            indices = []
+            for local_index in range(2 ** k):
+                index = base_index
+                for j, position in enumerate(bit_positions):
+                    bit = (local_index>> (k - j - 1)) & 1
+                    index |= (bit << position)
+                indices.append(index)
+            amplitudes = old_state[indices]
+            transformed = (matrix @ amplitudes)
+            for i, index in enumerate(indices):
+                new_state[index] = (transformed[i])
+        self._state = new_state
+    @property
+    def state(self):
+        return self._state
+    @property
+    def num_qubits(self):
+        return len(self.qubits)
+    @property
+    def dimension(self):
+        return 2 ** self.num_qubits
+    def normalize(self):
+        norm = np.linalg.norm(self._state)
+        if np.isclose(norm, 0):
+            raise ValueError("Cannot normalize zero state.")
+        self._state = (self._state / norm)
+        return self
+    @property
+    def notation(self):
+        terms = []
+        for index, amplitude in enumerate(self._state):
+            if np.isclose(amplitude,0):
+                continue
+            basis = format(index,f"0{self.num_qubits}b")
+            terms.append(f"{amplitude}|{basis}⟩")
+        return " + ".join(terms)
+    def __repr__(self):
+        return (f"StateVector("f"num_qubits={self.num_qubits}, "f"dimension={self.dimension})")
+__all__ = ["StateVector"]

oqubit/gates/__init__.py

@@ -0,0 +1,5 @@
+from ..core.operators import Operator,Gate
+from .single import X,Y,Z,H,S,T,SX
+from .controlled import CX,CY,CZ,CH,CS,CSX,CT
+from .multi import SWAP,ISWAP,SQRT_SWAP,CCX,CSWAP
+__all__=["X","Y","Z","H","S","T","SX","CX","CY","CZ","CH","CS","CSX","CT","SWAP","ISWAP","SQRT_SWAP","CCX","CSWAP"]

oqubit/gates/controlled.py

@@ -0,0 +1,17 @@
+from ..core.operators import Gate,Operator
+import numpy as np
+"""
+These are Qubit gates which are cotrolled and requires atleast one Qubit control state to change the state of the other Qubit.
+
+Qubit gates such as CX (also known as CNOT), CY ,CZ , CH, CS, CT, CSX Gates are present.
+
+I hope you will enjoy learning creating new logical interpretation by using various series of Quantum Gates to Encode and Decode Informations.
+"""
+CX = Gate([[1, 0, 0, 0],[0, 1, 0, 0],[0, 0, 0, 1],[0, 0, 1, 0],],"CX",num_qubits=2,num_controls=1,num_targets=1,)
+CY = Gate([[1, 0, 0, 0],[0, 1, 0, 0],[0, 0, 0, -1j],[0, 0, 1j, 0],],"CY",num_qubits=2,num_controls=1,num_targets=1,)
+CZ = Gate([[1, 0, 0, 0],[0, 1, 0, 0],[0, 0, 1, 0],[0, 0, 0, -1],],"CZ",num_qubits=2,num_controls=1,num_targets=1,)
+CH = Gate([[1, 0, 0, 0],[0, 1, 0, 0],[0, 0, 1 / np.sqrt(2), 1 / np.sqrt(2)],[0, 0, 1 / np.sqrt(2), -1 / np.sqrt(2)],],"CH",num_qubits=2,num_controls=1,num_targets=1,)
+CS = Gate([[1, 0, 0, 0],[0, 1, 0, 0],[0, 0, 1, 0],[0, 0, 0, 1j],],"CS",num_qubits=2,num_controls=1,num_targets=1,)
+CT = Gate([[1, 0, 0, 0],[0, 1, 0, 0],[0, 0, 1, 0],[0, 0, 0, np.exp(1j * np.pi / 4)],],"CT",num_qubits=2,num_controls=1,num_targets=1,)
+CSX = Gate([[1, 0, 0, 0],[0, 1, 0, 0],[0, 0, (1 + 1j) / 2, (1 - 1j) / 2],[0, 0, (1 - 1j) / 2, (1 + 1j) / 2],],"CSX",num_qubits=2,num_controls=1,num_targets=1,)
+__all__ = ["CX","CY","CZ","CH","CS","CT","CSX"]