Bell's Inequality: How Quantum Mechanics Broke Local Reality Forever

# Classical hidden variable model
class ClassicalParticle:
    def __init__(self, hidden_angle):
        # Hidden variable determines all measurement outcomes
        self.hidden_angle = hidden_angle
    
    def measure_spin(self, detector_angle):
        # Classical correlation based on hidden variable
        relative_angle = abs(self.hidden_angle - detector_angle)
        # Returns +1 or -1 based on classical physics
        return 1 if relative_angle < math.pi/2 else -1

# This model predicts different correlations than QM!

import numpy as np
from math import sqrt, cos, sin, pi

def quantum_correlation(theta_a, theta_b):
    """Quantum mechanical correlation for spin-1/2 particles"""
    return -cos(theta_a - theta_b)

def calculate_chsh_quantum(a1, a2, b1, b2):
    """Calculate CHSH parameter for quantum predictions"""
    E11 = quantum_correlation(a1, b1)
    E12 = quantum_correlation(a1, b2) 
    E21 = quantum_correlation(a2, b1)
    E22 = quantum_correlation(a2, b2)
    
    S = abs(E11 + E12 + E21 - E22)
    return S

# Optimal angles for maximum violation
a1, a2 = 0, pi/2          # Alice's measurement angles
b1, b2 = pi/4, -pi/4      # Bob's measurement angles

S_quantum = calculate_chsh_quantum(a1, a2, b1, b2)
print(f"CHSH parameter: {S_quantum:.3f}")
print(f"Tsirelson bound: {2*sqrt(2):.3f}")
print(f"Bell inequality violated: {S_quantum > 2}")

# Simulating a realistic Bell test experiment
class BellExperiment:
    def __init__(self, detection_efficiency=0.8, background_rate=0.05):
        self.eta = detection_efficiency  # Detector efficiency
        self.background = background_rate # Background noise
    
    def measure_pair(self, theta_a, theta_b):
        """Simulate measurement of entangled photon pair"""
        # Quantum correlation (perfect case)
        correlation = -np.cos(theta_a - theta_b)
        
        # Random outcomes with quantum probabilities
        prob_same = (1 + correlation) / 2
        same_outcome = np.random.random() < prob_same
        
        # Detection and background effects
        detect_a = np.random.random() < self.eta
        detect_b = np.random.random() < self.eta
        
        if not (detect_a and detect_b):
            return None  # Lost detection event
            
        # Add background noise
        if np.random.random() < self.background:
            same_outcome = not same_outcome
            
        return (1, 1) if same_outcome else (1, -1)
    
    def run_bell_test(self, angles, num_trials=10000):
        """Run complete Bell test with given angles"""
        a1, a2, b1, b2 = angles
        correlations = {}
        
        for (theta_a, theta_b, label) in [(a1,b1,'++'), (a1,b2,'+-'), 
                                         (a2,b1,'-+'), (a2,b2,'--')]:
            results = []
            for _ in range(num_trials):
                result = self.measure_pair(theta_a, theta_b)
                if result:  # Valid detection
                    results.append(result[0] * result[1])
            
            correlations[label] = np.mean(results) if results else 0
        
        # Calculate CHSH parameter
        S = abs(correlations['++'] + correlations['+-'] + 
                correlations['-+'] - correlations['--'])
        
        return S, correlations

# Quantum circuit for Bell test (using Qiskit-style syntax)
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.extensions import RYGate, RZGate

def create_bell_test_circuit(theta_a, theta_b):
    """Create quantum circuit for Bell test measurement"""
    
    # Two qubits for the entangled pair
    qr = QuantumRegister(2, 'q')
    cr = ClassicalRegister(2, 'c')
    qc = QuantumCircuit(qr, cr)
    
    # Create Bell state |Φ⁺⟩ = (|00⟩ + |11⟩)/√2
    qc.h(qr[0])           # Hadamard on first qubit
    qc.cx(qr[0], qr[1])   # CNOT to create entanglement
    
    # Measurement rotations
    # Alice's measurement along angle theta_a
    qc.ry(-2*theta_a, qr[0])
    
    # Bob's measurement along angle theta_b  
    qc.ry(-2*theta_b, qr[1])
    
    # Measurements in computational basis
    qc.measure(qr[0], cr[0])
    qc.measure(qr[1], cr[1])
    
    return qc

def analyze_bell_results(counts, total_shots):
    """Analyze measurement results for correlation"""
    same_outcomes = counts.get('00', 0) + counts.get('11', 0)
    diff_outcomes = counts.get('01', 0) + counts.get('10', 0)
    
    correlation = (same_outcomes - diff_outcomes) / total_shots
    return correlation

# Example usage for optimal CHSH angles
angles_optimal = [0, np.pi/2, np.pi/4, -np.pi/4]
print("Quantum circuits for optimal Bell violation:")
for i, (a, b) in enumerate([(angles_optimal[0], angles_optimal[2]),
                           (angles_optimal[0], angles_optimal[3]),
                           (angles_optimal[1], angles_optimal[2]),
                           (angles_optimal[1], angles_optimal[3])]):
    circuit = create_bell_test_circuit(a, b)
    print(f"Circuit {i+1}: Alice={a:.3f}, Bob={b:.3f}")

# Application: Quantum Key Distribution with Bell tests
class QuantumKeyDistribution:
    def __init__(self):
        self.bell_violations = []
        self.key_bits = []
    
    def perform_bell_test(self, measurement_fraction=0.1):
        """Perform Bell test on fraction of entangled pairs"""
        # In real QKD, some pairs test Bell violations
        # to verify security against eavesdropping
        
        test_correlations = []
        for _ in range(int(1000 * measurement_fraction)):
            # Simulate Bell test measurement
            angle_a = np.random.choice([0, np.pi/2])
            angle_b = np.random.choice([np.pi/4, -np.pi/4])
            
            correlation = -np.cos(angle_a - angle_b)
            # Add realistic noise
            correlation += np.random.normal(0, 0.1)
            test_correlations.append(correlation)
        
        # Calculate CHSH violation
        S = abs(np.mean(test_correlations)) * 4
        self.bell_violations.append(S)
        
        return S > 2  # Security verified if violation detected
    
    def generate_key(self, num_bits):
        """Generate quantum key after security verification"""
        if not self.perform_bell_test():
            raise SecurityWarning("Bell test failed - potential eavesdropper!")
        
        # Generate key from remaining entangled pairs
        for _ in range(num_bits):
            # Random measurement basis choice
            bit = np.random.randint(0, 2)
            self.key_bits.append(bit)
        
        return self.key_bits

# Example: Secure quantum key generation
qkd = QuantumKeyDistribution()
try:
    secure_key = qkd.generate_key(256)
    print(f"Generated {len(secure_key)}-bit quantum key")
    print(f"Bell violation: S = {qkd.bell_violations[-1]:.3f}")
except SecurityWarning as e:
    print(f"Security compromised: {e}")