psiqit 1.0.0__tar.gz

psiqit-1.0.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: psiqit
+Version: 1.0.0
+Summary: Quantum Information Toolkit
+Author: mahdi azad marzabadi , Dr.mahdi mirzaee , Dr.karim ghorbani
+Author-email: QIT Development Team <qit@example.com>
+License-Expression: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: scipy>=1.7.0
+Dynamic: author
+Dynamic: requires-python

psiqit-1.0.0/psiqit/__init__.py

@@ -0,0 +1,19 @@
+"""
+psyqit - Quantum Information Toolkit
+"""
+
+__version__ = "0.1.0"
+__author__ = "mahdi azadmarzabadi , Dr.mahdi mirzaee , Dr.karim ghorbani"
+
+# Core exports
+from .quantum.state import Ket, Bra, zero, one, plus, minus
+from .quantum.operator import hadamard, pauli_x, pauli_y, pauli_z, cnot
+from .circuits.circuit import QuantumCircuit
+
+__all__ = [
+    '__version__',
+    '__author__',
+    'Ket', 'Bra', 'zero', 'one', 'plus', 'minus',
+    'hadamard', 'pauli_x', 'pauli_y', 'pauli_z', 'cnot',
+    'QuantumCircuit',
+]

psiqit-1.0.0/psiqit/algorithms/__init__.py

@@ -0,0 +1,30 @@
+"""
+qit/algorithms/__init__.py
+Quantum algorithms module
+"""
+
+from .grover import Grover, grover_search, grover_search_multiple
+from .deutsch_jozsa import (
+    DeutschJozsaResult,
+    DeutschJozsa,
+    DeutschAlgorithm,
+    deutsch_jozsa_constant,
+    deutsch_jozsa_balanced,
+    deutsch_algorithm_constant,
+    deutsch_algorithm_balanced,
+)
+
+__all__ = [
+    # Grover
+    'Grover',
+    'grover_search',
+    'grover_search_multiple',
+    # Deutsch-Jozsa
+    'DeutschJozsaResult',
+    'DeutschJozsa',
+    'DeutschAlgorithm',
+    'deutsch_jozsa_constant',
+    'deutsch_jozsa_balanced',
+    'deutsch_algorithm_constant',
+    'deutsch_algorithm_balanced',
+]

psiqit-1.0.0/psiqit/algorithms/bernstein_vazirani.py

@@ -0,0 +1,97 @@
+"""
+qit/algorithms/bernstein_vazirani.py
+Bernstein-Vazirani Algorithm - Fixed
+"""
+
+from typing import Callable, List, Optional
+from dataclasses import dataclass
+
+from ..circuits.circuit import QuantumCircuit
+from ..quantum.state import Ket, basis
+from ..quantum.operator import hadamard, cnot, pauli_x
+from ..quantum.measurement import measure
+
+
+@dataclass
+class BernsteinVaziraniResult:
+    hidden_string: int
+    n_qubits: int
+    success: bool
+    
+    def __str__(self) -> str:
+        bits = format(self.hidden_string, f'0{self.n_qubits}b')
+        return f"Hidden string: {bits} (decimal: {self.hidden_string})"
+
+
+class BernsteinVazirani:
+    """
+    Bernstein-Vazirani algorithm for finding hidden bit string.
+    """
+    
+    def __init__(self, n_qubits: int):
+        self.n = n_qubits
+        self.total_qubits = n_qubits + 1
+    
+    def build_circuit(self, oracle: Callable) -> QuantumCircuit:
+        """Build Bernstein-Vazirani circuit."""
+        circuit = QuantumCircuit(self.total_qubits)
+        
+        # Initialize ancilla to |1⟩
+        circuit.x(self.n)
+        
+        # Apply Hadamard to all qubits
+        for i in range(self.total_qubits):
+            circuit.h(i)
+        
+        # Apply oracle (simplified - just CNOTs)
+        for i in range(self.n):
+            circuit.cx(i, self.n)
+        
+        # Apply Hadamard to input qubits
+        for i in range(self.n):
+            circuit.h(i)
+        
+        return circuit
+    
+    def run(self) -> BernsteinVaziraniResult:
+        """Run Bernstein-Vazirani algorithm."""
+        circuit = self.build_circuit(None)
+        state = circuit.run()
+        
+        # Measure input qubits
+        measurements = []
+        for i in range(self.n):
+            prob_0 = 0
+            dim = state.dim
+            for j in range(dim):
+                bit = (j >> (self.total_qubits - 1 - i)) & 1
+                if bit == 0:
+                    prob_0 += abs(state.data[j]) ** 2
+            measurements.append(0 if prob_0 > 0.5 else 1)
+        
+        # Convert to integer
+        hidden_string = 0
+        for i, bit in enumerate(measurements):
+            hidden_string = (hidden_string << 1) | bit
+        
+        return BernsteinVaziraniResult(
+            hidden_string=hidden_string,
+            n_qubits=self.n,
+            success=True
+        )
+
+
+def bernstein_vazirani(n_qubits: int) -> int:
+    """
+    Convenience function for Bernstein-Vazirani algorithm.
+    """
+    bv = BernsteinVazirani(n_qubits)
+    result = bv.run()
+    return result.hidden_string
+
+
+__all__ = [
+    'BernsteinVaziraniResult',
+    'BernsteinVazirani',
+    'bernstein_vazirani',
+]

psiqit-1.0.0/psiqit/algorithms/deutsch_jozsa.py

@@ -0,0 +1,214 @@
+"""
+qit/algorithms/deutsch_jozsa.py
+Deutsch-Jozsa Algorithm - Fixed with circuit.measure
+"""
+
+import math
+from typing import List, Optional, Union, Callable, Dict
+from dataclasses import dataclass
+
+from ..circuits.circuit import QuantumCircuit
+from ..quantum.state import Ket, zero, one, basis
+from ..quantum.operator import hadamard, pauli_x, cnot, toffoli
+from ..quantum.measurement import measure
+
+
+@dataclass
+class DeutschJozsaResult:
+    is_constant: bool
+    is_balanced: bool
+    measurement_result: int
+    n_qubits: int
+    oracle_type: str
+    confidence: float = 1.0
+    
+    def __str__(self) -> str:
+        if self.is_constant:
+            return f"Function is CONSTANT (f(x) = 0 for all x)"
+        else:
+            return f"Function is BALANCED (exactly half 0s, half 1s)"
+
+
+class DeutschJozsa:
+    """
+    Deutsch-Jozsa algorithm implementation.
+    """
+    
+    def __init__(self, n_qubits: int, 
+                 oracle_type: str = 'constant',
+                 constant_value: int = 0,
+                 custom_oracle: Optional[Callable] = None):
+        
+        self.n_qubits = n_qubits
+        self.oracle_type = oracle_type
+        self.constant_value = constant_value
+        
+        if custom_oracle:
+            self.oracle = custom_oracle
+            self.oracle_type = 'custom'
+        else:
+            self.oracle = self._build_oracle()
+    
+    def _build_oracle(self) -> Callable:
+        """Build the oracle for the Deutsch-Jozsa algorithm."""
+        
+        def constant_oracle(circuit: QuantumCircuit):
+            """Constant oracle: f(x) = constant_value for all x."""
+            if self.constant_value == 1:
+                circuit.x(self.n_qubits)
+        
+        def balanced_oracle(circuit: QuantumCircuit):
+            """Balanced oracle: f(x) = x_0 (first bit determines output)"""
+            circuit.cx(0, self.n_qubits)
+        
+        if self.oracle_type == 'constant':
+            return constant_oracle
+        elif self.oracle_type == 'balanced':
+            return balanced_oracle
+        else:
+            raise ValueError(f"Unknown oracle type: {self.oracle_type}")
+    
+    def build_circuit(self) -> QuantumCircuit:
+        """Build the complete Deutsch-Jozsa circuit."""
+        total_qubits = self.n_qubits + 1
+        circuit = QuantumCircuit(total_qubits)
+        
+        # Initialize ancilla qubit to |1⟩
+        circuit.x(self.n_qubits)
+        
+        # Apply Hadamard to all qubits
+        for i in range(total_qubits):
+            circuit.h(i)
+        
+        # Apply oracle
+        self.oracle(circuit)
+        
+        # Apply Hadamard to input qubits only
+        for i in range(self.n_qubits):
+            circuit.h(i)
+        
+        return circuit
+    
+    def run(self, shots: int = 100) -> DeutschJozsaResult:
+        """
+        Run the Deutsch-Jozsa algorithm.
+        
+        Args:
+            shots: Number of measurements (higher = more accurate)
+        """
+        circuit = self.build_circuit()
+        
+        # Measure all qubits
+        results = circuit.measure(shots=shots)
+        
+        # For Deutsch-Jozsa, we only care about the input qubits
+        # We check if all measurements of input qubits are 0
+        n = self.n_qubits
+        
+        # Count how many measurements have all input qubits = 0
+        zero_count = 0
+        for bitstring, count in results.items():
+            # Check if first n bits are all '0'
+            if bitstring[:n] == '0' * n:
+                zero_count += count
+        
+        # If more than 50% of measurements are all zeros, function is constant
+        # (In theory, it should be 100% for constant, 0% for balanced)
+        is_constant = (zero_count / shots) > 0.5
+        
+        return DeutschJozsaResult(
+            is_constant=is_constant,
+            is_balanced=not is_constant,
+            measurement_result=0 if is_constant else 1,
+            n_qubits=self.n_qubits,
+            oracle_type=self.oracle_type,
+            confidence=zero_count / shots
+        )
+
+
+# ============================================================
+# Simplified version for 1-qubit (Deutsch algorithm)
+# ============================================================
+
+class DeutschAlgorithm:
+    """Simplified Deutsch algorithm (1-qubit version)."""
+    
+    def __init__(self, oracle_type: str = 'constant', constant_value: int = 0):
+        self.oracle_type = oracle_type
+        self.constant_value = constant_value
+    
+    def _apply_oracle(self, circuit: QuantumCircuit):
+        """Apply 1-qubit oracle."""
+        if self.oracle_type == 'constant':
+            if self.constant_value == 1:
+                circuit.x(1)
+        else:  # balanced
+            circuit.cx(0, 1)
+    
+    def build_circuit(self) -> QuantumCircuit:
+        """Build Deutsch circuit."""
+        circuit = QuantumCircuit(2)
+        
+        circuit.x(1)
+        circuit.h(0)
+        circuit.h(1)
+        self._apply_oracle(circuit)
+        circuit.h(0)
+        
+        return circuit
+    
+    def run(self, shots: int = 100) -> Dict:
+        """Run Deutsch algorithm."""
+        circuit = self.build_circuit()
+        results = circuit.measure(shots=shots)
+        
+        # Count measurements where first qubit is 0
+        zero_count = 0
+        for bitstring, count in results.items():
+            if bitstring[0] == '0':
+                zero_count += count
+        
+        is_constant = (zero_count / shots) > 0.5
+        
+        return {
+            'is_constant': is_constant,
+            'is_balanced': not is_constant,
+            'measurement': '0' if is_constant else '1',
+            'oracle_type': self.oracle_type,
+            'confidence': zero_count / shots if is_constant else (shots - zero_count) / shots
+        }
+
+
+# ============================================================
+# Convenience Functions
+# ============================================================
+
+def deutsch_jozsa_constant(n_qubits: int = 3, constant_value: int = 0, shots: int = 100) -> DeutschJozsaResult:
+    dj = DeutschJozsa(n_qubits, oracle_type='constant', constant_value=constant_value)
+    return dj.run(shots)
+
+
+def deutsch_jozsa_balanced(n_qubits: int = 3, shots: int = 100) -> DeutschJozsaResult:
+    dj = DeutschJozsa(n_qubits, oracle_type='balanced')
+    return dj.run(shots)
+
+
+def deutsch_algorithm_constant(constant_value: int = 0, shots: int = 100) -> Dict:
+    da = DeutschAlgorithm(oracle_type='constant', constant_value=constant_value)
+    return da.run(shots)
+
+
+def deutsch_algorithm_balanced(shots: int = 100) -> Dict:
+    da = DeutschAlgorithm(oracle_type='balanced')
+    return da.run(shots)
+
+
+__all__ = [
+    'DeutschJozsaResult',
+    'DeutschJozsa',
+    'DeutschAlgorithm',
+    'deutsch_jozsa_constant',
+    'deutsch_jozsa_balanced',
+    'deutsch_algorithm_constant',
+    'deutsch_algorithm_balanced',
+]

psiqit-1.0.0/psiqit/algorithms/grover.py

@@ -0,0 +1,245 @@
+"""
+qit/algorithms/grover.py
+Grover's Search Algorithm - Complete Implementation
+"""
+
+import math
+import random
+from typing import List, Optional, Union, Dict
+from dataclasses import dataclass
+
+from ..circuits.circuit import QuantumCircuit
+from ..quantum.state import Ket, basis
+from ..quantum.operator import hadamard, pauli_z, cnot, toffoli, cz
+from ..quantum.measurement import measure
+
+
+@dataclass
+class GroverResult:
+    counts: Dict[str, int]
+    most_likely: int
+    marked_states: List[int]
+    success: bool
+    n_iterations: int
+    theoretical_prob: float
+    
+    def __str__(self) -> str:
+        return (f"GroverResult(most_likely={self.most_likely}, "
+                f"success={self.success}, iterations={self.n_iterations})")
+
+
+class Grover:
+    """
+    Grover's search algorithm implementation.
+    """
+    
+    def __init__(self, n_qubits: int, marked_states: Union[int, List[int]]):
+        self.n_qubits = n_qubits
+        self.N = 2 ** n_qubits
+        
+        if isinstance(marked_states, int):
+            self.marked_states = [marked_states]
+        else:
+            self.marked_states = marked_states
+        
+        self.M = len(self.marked_states)
+        
+        # Calculate optimal iterations
+        if self.M <= 0 or self.M >= self.N:
+            self.n_iterations = 0
+        else:
+            theta = math.asin(math.sqrt(self.M / self.N))
+            self.n_iterations = max(1, int(round((math.pi / (4 * theta)) - 0.5)))
+    
+    def _get_binary(self, state: int) -> str:
+        """Convert state index to binary string."""
+        return format(state, f'0{self.n_qubits}b')
+    
+    def build_circuit(self) -> QuantumCircuit:
+        """
+        Build the complete Grover circuit.
+        
+        Returns:
+            QuantumCircuit: The Grover circuit
+        """
+        circuit = QuantumCircuit(self.n_qubits)
+        
+        # Initialize in uniform superposition
+        for i in range(self.n_qubits):
+            circuit.h(i)
+        
+        # Apply Grover iterations
+        for _ in range(self.n_iterations):
+            # Oracle (simplified for now)
+            for target in self.marked_states:
+                binary = self._get_binary(target)
+                for i, bit in enumerate(binary):
+                    if bit == '0':
+                        circuit.x(i)
+                circuit.cz(0, 1)  # Simplified multi-controlled Z
+                for i, bit in enumerate(binary):
+                    if bit == '0':
+                        circuit.x(i)
+            
+            # Diffuser
+            for i in range(self.n_qubits):
+                circuit.h(i)
+            for i in range(self.n_qubits):
+                circuit.x(i)
+            circuit.cz(0, 1)
+            for i in range(self.n_qubits):
+                circuit.x(i)
+            for i in range(self.n_qubits):
+                circuit.h(i)
+        
+        return circuit
+    
+    def get_probabilities(self) -> List[float]:
+        """
+        Calculate theoretical probabilities for each state.
+        
+        Returns:
+            List of probabilities
+        """
+        probs = [0.0] * self.N
+        
+        if self.M == 0 or self.M == self.N:
+            return [1.0 / self.N] * self.N
+        
+        theta = math.asin(math.sqrt(self.M / self.N))
+        prob_marked = math.sin((2 * self.n_iterations + 1) * theta) ** 2
+        prob_unmarked = (1 - prob_marked) / (self.N - self.M) if self.N > self.M else 0
+        
+        for state in self.marked_states:
+            probs[state] = prob_marked / self.M
+        for i in range(self.N):
+            if i not in self.marked_states:
+                probs[i] = prob_unmarked
+        
+        return probs
+    
+    def _apply_gate_to_state(self, state: Ket, gate_matrix, qubits: List[int]) -> Ket:
+        """Apply a gate to specific qubits."""
+        n = self.n_qubits
+        dim = state.dim
+        new_data = [0j] * dim
+        
+        for i in range(dim):
+            bits = [(i >> (n - 1 - k)) & 1 for k in range(n)]
+            
+            if len(qubits) == 1:
+                q = qubits[0]
+                row = bits[q]
+                for j in range(2):
+                    new_bits = bits.copy()
+                    new_bits[q] = j
+                    new_idx = 0
+                    for k, b in enumerate(new_bits):
+                        new_idx = (new_idx << 1) | b
+                    new_data[new_idx] += gate_matrix[row][j] * state.data[i]
+            
+            elif len(qubits) == 2 and len(gate_matrix) == 4:
+                q1, q2 = qubits
+                row = (bits[q1] << 1) | bits[q2]
+                for j1 in range(2):
+                    for j2 in range(2):
+                        col = (j1 << 1) | j2
+                        new_bits = bits.copy()
+                        new_bits[q1] = j1
+                        new_bits[q2] = j2
+                        new_idx = 0
+                        for k, b in enumerate(new_bits):
+                            new_idx = (new_idx << 1) | b
+                        new_data[new_idx] += gate_matrix[row][col] * state.data[i]
+        
+        return Ket(new_data)
+    
+    def _oracle(self, state: Ket) -> Ket:
+        """Apply phase oracle to mark target states."""
+        new_data = state.data.copy()
+        for target in self.marked_states:
+            new_data[target] = -new_data[target]
+        return Ket(new_data)
+    
+    def _diffuser(self, state: Ket) -> Ket:
+        """Apply Grover diffusion operator."""
+        n = self.N
+        avg = sum(state.data) / n
+        new_data = [2 * avg - a for a in state.data]
+        return Ket(new_data)
+    
+    def run(self, shots: int = 1024) -> GroverResult:
+        """Run Grover's algorithm."""
+        # Start from |0...0⟩
+        state = basis(self.N, 0)
+        
+        # Apply Hadamard to all qubits
+        from ..quantum.operator import hadamard
+        H = hadamard()
+        for i in range(self.n_qubits):
+            state = self._apply_gate_to_state(state, H.data, [i])
+        
+        # Apply Grover iterations
+        for _ in range(self.n_iterations):
+            state = self._oracle(state)
+            state = self._diffuser(state)
+        
+        # Measure
+        probs = [abs(a)**2 for a in state.data]
+        total = sum(probs)
+        probs = [p / total for p in probs]
+        
+        outcomes = []
+        for _ in range(shots):
+            r = random.random()
+            cumsum = 0
+            for i, p in enumerate(probs):
+                cumsum += p
+                if r < cumsum:
+                    outcomes.append(i)
+                    break
+        
+        outcome_strings = [format(o, f'0{self.n_qubits}b') for o in outcomes]
+        
+        counts = {}
+        for s in outcome_strings:
+            counts[s] = counts.get(s, 0) + 1
+        
+        most_likely = max(counts, key=counts.get) if counts else None
+        most_likely_int = int(most_likely, 2) if most_likely else None
+        
+        # Theoretical probability
+        if self.M > 0 and self.M < self.N:
+            theta = math.asin(math.sqrt(self.M / self.N))
+            prob_marked = math.sin((2 * self.n_iterations + 1) * theta) ** 2
+        else:
+            prob_marked = 1.0 if self.M == self.N else 0.0
+        
+        success = most_likely_int in self.marked_states if most_likely_int is not None else False
+        
+        return GroverResult(
+            counts=counts,
+            most_likely=most_likely_int,
+            marked_states=self.marked_states,
+            success=success,
+            n_iterations=self.n_iterations,
+            theoretical_prob=prob_marked
+        )
+
+
+def grover_search(n_qubits: int, target: int, shots: int = 1024) -> GroverResult:
+    grover = Grover(n_qubits, target)
+    return grover.run(shots)
+
+
+def grover_search_multiple(n_qubits: int, targets: List[int], shots: int = 1024) -> GroverResult:
+    grover = Grover(n_qubits, targets)
+    return grover.run(shots)
+
+
+__all__ = [
+    'GroverResult',
+    'Grover',
+    'grover_search',
+    'grover_search_multiple',
+]