import random

# Define the eight deterministic plans as dicts mapping axis→outcome
PLANS = [
    {1:+1, 2:+1, 3:+1},  # Plan 1: (↑↑↑)
    {1:+1, 2:+1, 3:-1},  # Plan 2: (↑↑↓)
    {1:+1, 2:-1, 3:+1},  # Plan 3: (↑↓↑)
    {1:+1, 2:-1, 3:-1},  # Plan 4: (↑↓↓)
    {1:-1, 2:+1, 3:+1},  # Plan 5: (↓↑↑)
    {1:-1, 2:+1, 3:-1},  # Plan 6: (↓↑↓)
    {1:-1, 2:-1, 3:+1},  # Plan 7: (↓↓↑)
    {1:-1, 2:-1, 3:-1},  # Plan 8: (↓↓↓)
]

def simulate_hidden_variable(runs=10000):
    mismatches = 0
    for _ in range(runs):
        plan = random.choice(PLANS)
        # randomly pick measurement axes i, j ∈ {1,2,3}
        i = random.randint(1,3)
        j = random.randint(1,3)
        a = plan[i]  # Alice’s outcome
        b = -plan[j]  # Bob’s outcome is opposite on same-axis
        if a != b:
            mismatches += 1
    return mismatches / runs

print(simulate_hidden_variable())  # ≳0.56 (never reaches 0.50)

import random
import math

def simulate_singlet(runs=10000):
    mismatches = 0
    for _ in range(runs):
        # pick axes i, j ∈ {1,2,3}, represented by angles θ_i=0°,120°,240°
        angles = {1:0, 2:120, 3:240}
        i, j = random.randint(1,3), random.randint(1,3)
        θ = abs(angles[i] - angles[j]) % 360
        if θ > 180:
            θ = 360 - θ
        # Probability of “different” for singlet: P = ½(1 + cos θ)
        p_diff = 0.5 * (1 + math.cos(math.radians(θ)))
        if random.random() < p_diff:
            mismatches += 1
    return mismatches / runs

print(simulate_singlet())  # ≃0.50

def simulate(runs=10000):
    mismatches = 0
    for _ in range(runs):
        plan = random.choice(PLANS)
        # randomly pick measurement axes i, j ∈ {1,2,3}
        i = random.randint(1,3)
        j = random.randint(1,3)
        if is_diff(i, j):
            mismatches += 1
    return mismatches / runs

def is_diff_hidden(i, j):
    plan = generate_plan_from_distribution(random.random())
    return plan[i] != plan[j]

def is_diff_quantum(i, j):
    # simple math function of i and j 
    p_diff = 0.5 * (1 + cos(angles[i] - angles[j]))
    return random.random() < p_diff