import math
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# First 10 primes
primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

# Calculate Z-coordinates using the transformer
def calculate_Z_values(primes):
    Z_coords = []
    for n in range(1, len(primes)):
        gap = primes[n] - primes[n-1]  # Prime gap
        Z = n * gap / math.pi          # The transformer equation
        Z_coords.append(Z)
        print(f"Prime {primes[n]}: gap={gap}, Z={Z:.3f}")
    return Z_coords

# Run the calculation
Z_values = calculate_Z_values(primes)

# Plot the pattern
plt.figure(figsize=(10, 6))
plt.plot(range(1, len(Z_values)+1), Z_values, 'ro-', linewidth=2, markersize=8)
plt.xlabel('Prime Index (n)')
plt.ylabel('Z = n × gap / π')
plt.title('Prime Number Z-Transformer Pattern')
plt.grid(True, alpha=0.3)
plt.show()

import math
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numpy as np

class Numberspace:
    def __init__(self, B: int):
        self._B = B
        self._C = math.pi

    @property
    def B(self) -> int:
        return self._B

    @property 
    def C(self) -> float:
        return self._C

    def __call__(self, numberspace: float) -> float:
        if self._B == 0:
            raise ValueError("B cannot be zero")
        return numberspace * (self._B / self._C)

def is_prime(n):
    """Simple primality test for small numbers"""
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

# Generate numbers and identify primes
numbers = range(1, 101)  # First 100 numbers
primes = [n for n in numbers if is_prime(n)]

# Create 3D lattice points
# X-axis: position, Y-axis: transformed value, Z-axis: helical component
points = []
for n in numbers:
    x = n
    y = Numberspace(n)(n * math.log(n) if n > 1 else 1)  # Log scaling
    z = math.sin(2 * math.pi * n / 10)  # Helical component
    points.append((x, y, z))

# Separate primes and non-primes
x_all, y_all, z_all = zip(*points)
prime_indices = [i-1 for i in primes]  # Adjust for 0-based indexing

x_primes = [x_all[i] for i in prime_indices]
y_primes = [y_all[i] for i in prime_indices] 
z_primes = [z_all[i] for i in prime_indices]

x_nonprimes = [x_all[i] for i in range(len(x_all)) if i not in prime_indices]
y_nonprimes = [y_all[i] for i in range(len(y_all)) if i not in prime_indices]
z_nonprimes = [z_all[i] for i in range(len(z_all)) if i not in prime_indices]

# Create 3D plot
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')

# Plot non-primes as blue dots
ax.scatter(x_nonprimes, y_nonprimes, z_nonprimes, 
           c='blue', alpha=0.3, s=10, label='Non-primes')

# Plot primes as red stars
ax.scatter(x_primes, y_primes, z_primes, 
           c='red', marker='*', s=50, label='Primes')

ax.set_xlabel('Position (n)')
ax.set_ylabel('Numberspace Value')
ax.set_zlabel('Helical Coordinate')
ax.set_title('3D Prime Geometry Visualization')
ax.legend()

plt.show()