import numpy as np
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings("ignore")

# ==============================================================================
# POSTULADOS FUNDAMENTALES TCDS — SIN ENERGÍA EXÓTICA
# ==============================================================================
# Constantes físicas y parámetros de la red
c = 299792458                  # Velocidad de la luz en vacío (m/s)
L_min = 1.0e-15                # Longitud mínima indivisible de la red (~fm)
phi = (1.0 + np.sqrt(5.0))/2.0 # Fricción topológica finita = φ ≈ 1.618
kappa = -5.682181              # Amplitud del desnivel estructural
n = 9.314138                   # Exponente topológico de red 3D
LI_0 = 0.02                    # Estado base de nodo relajado

# DATOS LHC como escala de perturbación experimental
E_lhc_TeV = 13.6
radio_impacto_fm = 0.8
amplitud_desacople = E_lhc_TeV / 100.0

# ==============================================================================
# POSTULADO 1: LÍMITE DE ACTUALIZACIÓN DE LA RED — K_RATE
# ==============================================================================
# K_RATE = c / L_min: frecuencia máxima a la que la red puede sincronizar nodos
K_RATE = c / L_min
print("="*70)
print("POSTULADO 1 — LÍMITE CAUSAL DE LA RED DISCRETA")
print("="*70)
print(f"Longitud mínima indivisible L_min = {L_min:.2e} m")
print(f"Velocidad de propagación máxima c = {c:.2e} m/s")
print(f"Frecuencia de actualización máxima K_RATE = {K_RATE:.2e} Hz")
print()
print("→ La burbuja NO puede propagarse más rápido que la red se actualiza.")
print("→ K_RATE acota estrictamente la velocidad: v ≤ c. Sin superluminalidad.")
print("→ Sin violación de causalidad, sin paradojas temporales.")
print()

# ==============================================================================
# POSTULADO 2: PROPAGACIÓN DE ESTADO, NO DESPLAZAMIENTO
# ==============================================================================
# Dominio de nodos discretos del sustrato
N_nodos = 2000
x = np.linspace(-3.0, 3.0, N_nodos) * L_min  # Posición física de cada nodo
R_bubble = 1.0 * L_min

# Función de forma: perfil de estado de la burbuja
# Frente: compresión LI→1 | Espalda: relajación LI→0
f_alcubierre = (np.tanh(10 * (x/L_min + R_bubble/L_min)) - 
                np.tanh(10 * (x/L_min - R_bubble/L_min))) / 2.0
pulso_lhc = amplitud_desacople * (x/L_min / radio_impacto_fm) * np.exp(-0.5 * (x/L_min / radio_impacto_fm)**2)
LI_x = LI_0 + (1.0 - LI_0) * f_alcubierre * (1.0 + 0.1 * np.sin(np.pi * x/R_bubble)) + pulso_lhc
LI_x = np.clip(LI_x, 0.0, 1.0)

# ==============================================================================
# POSTULADO 3: GEODÉSICA DE DESNIVEL TOPOLÓGICO — SIN MASA, SIN INERCIA
# ==============================================================================
# Gradiente de estado: dLI/dx → mide cuánto cambia el sustrato entre nodos
dLI_dx = np.gradient(LI_x, x)

# Desnivel topológico g(x): la "fuerza" que propaga el estado
# g(x) = -κ · n · LI^(n-1) · |dLI/dx|
# NOTA: NO aparece la masa de la nave. El término de aceleración NO depende de M.
g_x = -kappa * n * (LI_x**(n - 1.0)) * np.abs(dLI_dx)

# Costo de fricción topológica T(x): único costo finito
# T(x) = |dg/dx| ∝ φ — peaje que cobra la red por actualizar sus bordes
dg_dx = np.gradient(g_x, x)
T_x = np.abs(dg_dx)

# ==============================================================================
# POSTULADO 4: VELOCIDAD DE PROPAGACIÓN = v_propag = K_RATE · L_min = c
# ==============================================================================
# La velocidad de la burbuja está determinada EXCLUSIVAMENTE por la red, no por la nave
v_burbuja = K_RATE * L_min  # = c por definición
v_fraccion_c = v_burbuja / c

# Aceleración instantánea: Δv/Δt = v_burbuja / (1/K_RATE) = c · K_RATE
a_max = c * K_RATE

print("="*70)
print("POSTULADO 2-4 — PROPAGACIÓN DE ESTADO Y LÍMITE DE VELOCIDAD")
print("="*70)
print(f"Velocidad de burbuja v = {v_burbuja:.2e} m/s = {v_fraccion_c:.4f} · c")
print(f"Aceleración máxima instantánea a_max = {a_max:.2e} m/s²")
print(f"→ No hay masa en la fórmula: la nave no se desplaza, se propaga su ESTADO")
print(f"→ Aceleración instantánea SIN fuerzas G: el centro de la burbuja estático")
print(f"→ Costo energético: SOLO fricción topológica φ = {phi:.6f} (FINITO)")
print()

# ==============================================================================
# POSTULADO 5: LATENCIA Y RENDIMIENTO DEL MARCO ALGEBRAICO VECTORIZADO
# ==============================================================================
import time

# Simulamos actualización de la red: enfoque tradicional vs vectorizado
def actualizacion_tradicional(LI_actual, g_actual, pasos=1000):
    t0 = time.perf_counter()
    for _ in range(pasos):
        for i in range(len(LI_actual)):
            g_actual[i] = -kappa * n * (LI_actual[i]**(n-1)) * np.abs(np.gradient(LI_actual, x)[i])
    return time.perf_counter() - t0

def actualizacion_vectorizada(LI_actual):
    t0 = time.perf_counter()
    dLI = np.gradient(LI_actual, x)
    g_actual = -kappa * n * (LI_actual**(n - 1.0)) * np.abs(dLI)
    return time.perf_counter() - t0, g_actual

# Ejecución comparativa
t_trad = actualizacion_tradicional(LI_x.copy(), g_x.copy(), pasos=100)
t_vec, g_vec = actualizacion_vectorizada(LI_x.copy())
aceleracion = t_trad / t_vec
coincide = np.allclose(g_x, g_vec)

print("="*70)
print("POSTULADO 5 — LATENCIA DEL MARCO ALGEBRAICO VECTORIZADO")
print("="*70)
print(f"Actualización tradicional (bucle):    {t_trad*1000:>10.2f} ms")
print(f"Actualización vectorizada (bloques):  {t_vec*1000:>10.2f} ms")
print(f"Factor de aceleración:                 {aceleracion:>10.1f} ×")
print(f"Exactitud matemática:                  {'IDENTICA' if coincide else 'DIFERENTE'}")
print()
print(f"→ La latencia del software NO altera la física: K_RATE es el límite físico")
print(f"→ El marco vectorizado simplemente aproxima el límite teórico más rápido")
print(f"→ Potencia computacional liberada: hasta {aceleracion:.0f}× más nodos simulables")
print()

# ==============================================================================
# VISUALIZACIÓN — TODOS LOS POSTULADOS EN UN SOLO DIAGRAMA
# ==============================================================================
fig = plt.figure(figsize=(14, 16), facecolor='white')
gs = fig.add_gridspec(5, 1, height_ratios=[1, 1, 1, 1, 0.8], hspace=0.45)

# PANEL 0: ILUSTRACIÓN DEL CONCEPTO — PÍXELES QUE CAMBIAN DE ESTADO
ax0 = fig.add_subplot(gs[0])
ax0.set_facecolor('#f0f4ff')
ancho_aparente = 1.0 - 0.7 * LI_x
y_upper = 0.5 + ancho_aparente * 0.4
y_lower = 0.5 - ancho_aparente * 0.4

ax0.fill_between(x/L_min, y_lower, y_upper, color='#3b82f6', alpha=0.2)
ax0.plot(x/L_min, y_upper, color='#1e3a8a', lw=2.5, label='Frente de Compresión (LI→1)')
ax0.plot(x/L_min, y_lower, color='#1e3a8a', lw=2.5, label='Espalda de Relajación (LI→0)')

# Flechas de transferencia de nodo a nodo
for i in range(50, 150, 20):
    ax0.annotate('', xy=(x[i+10]/L_min, 0.5), xytext=(x[i]/L_min, 0.5),
                 arrowprops=dict(arrowstyle='->', color='#f59e0b', lw=1.5, alpha=0.7))

ax0.axvline(0, color='#dc2626', lw=2, linestyle='-', label='Centro estático / Nave')
ax0.set_xlim(-3, 3); ax0.set_ylim(0, 1)
ax0.set_title(r'PROPAGACIÓN DE ESTADO ≠ DESPLAZAMIENTO'+'\n'
              r'Los nodos no se mueven — transfieren su estado de tensión al siguiente. '
              r'Como píxeles en pantalla: ilusión de movimiento sin traslación material.',
              fontsize=13, fontweight='bold', color='#1e3a8a', pad=15)
ax0.legend(loc='upper right', framealpha=0.9)
ax0.set_yticks([])
ax0.set_xlabel(r'Posición en la red $x / L_{\min}$', fontsize=11)

# PANEL 1: PERFIL DE ESTADO LI(x)
ax1 = fig.add_subplot(gs[1])
ax1.plot(x/L_min, LI_x, color='#2563eb', lw=3, label=r'Estado de nodo $LI(x)$')
ax1.fill_between(x/L_min, 0, LI_x, color='#3b82f6', alpha=0.1)
ax1.axhline(LI_0, color='gray', ls=':', label=r'Estado base $LI_0$ (relajado)')
ax1.axhline(1.0, color='#64748b', ls='--', alpha=0.5, label=r'Estado comprimido $LI=1$')
ax1.axvline(0, color='#dc2626', ls='--', alpha=0.6)
ax1.set_ylabel(r'Estado $LI$', fontsize=12, fontweight='semibold')
ax1.set_title('PERFIL TOPOLÓGICO — Frente Comprimido, Espalda Relajada', fontsize=11, fontweight='bold')
ax1.set_xlim(-3, 3); ax1.set_ylim(0, 1.05)
ax1.grid(True, ls='--', alpha=0.3)
ax1.legend(loc='upper right')

# PANEL 2: DESNIVEL TOPOLÓGICO g(x) — SIN MASA
ax2 = fig.add_subplot(gs[2])
ax2.plot(x/L_min, g_x, color='#16a34a', lw=3,
         label=r'Desnivel $g(x) = -\kappa \, n \, LI^{n-1} \, |\nabla LI|$')
ax2.fill_between(x/L_min, 0, g_x, color='#16a34a', alpha=0.15)
ax2.axvline(0, color='#dc2626', ls='--', alpha=0.6)
ax2.set_ylabel(r'Tensión Topológica $g(x)$', fontsize=12, fontweight='semibold')
ax2.set_title('GEODÉSICA DE PROPAGACIÓN — No aparece la masa de la nave en la fórmula', fontsize=11, fontweight='bold')
ax2.set_xlim(-3, 3)
ax2.grid(True, ls='--', alpha=0.3)
ax2.legend(loc='upper right')

# PANEL 3: COSTO FINITO T(x) vs ENERGÍA EXÓTICA INFINITA
ax3 = fig.add_subplot(gs[3])
ax3.plot(x/L_min, T_x, color='#9333ea', lw=3,
         label=r'Fricción de red $T(x) \propto |\nabla g|$')
ax3.fill_between(x/L_min, 0, T_x, color='#9333ea', alpha=0.15)
ax3.axvline(0, color='#dc2626', ls='--', alpha=0.6)
ax3.text(2.0, np.max(T_x)*0.8, r'COSTO FINITO $\phi$'+'\n≠ Energía exótica infinita',
         fontsize=12, fontweight='bold', color='#7c3aed', ha='right')
ax3.set_ylabel(r'Costo de Fricción $T(x)$', fontsize=12, fontweight='semibold')
ax3.set_title('COSTO ENERGÉTICO — Peaje finito de la red, no materia exótica', fontsize=11, fontweight='bold')
ax3.set_xlabel(r'Posición en la red $x / L_{\min}$', fontsize=12, fontweight='semibold')
ax3.set_xlim(-3, 3)
ax3.grid(True, ls='--', alpha=0.3)
ax3.legend(loc='upper right')

# PANEL 4: RESUMEN DE LÍMITES
ax4 = fig.add_subplot(gs[4])
ax4.axis('off')
resumen = f"""
┌─────────────────────────────────────────────────────────────────────┐
│  LÍMITES FÍSICOS DE LA RED DISCRETA — TCDS                          │
├─────────────────────────────────────────────────────────────────────┤
│  K_RATE = c / L_min  = {K_RATE:.2e} Hz  ← Límite de actualización de nodo        │
│  v_max  = c          = {c:.2e} m/s      ← No superluminalidad, sin paradojas     │
│  a_max  = c·K_RATE   = {a_max:.2e} m/s²  ← Aceleración instantánea sin inercia   │
│  Costo  = φ          = {phi:.6f}          ← Finito, topológico, localizable       │
├─────────────────────────────────────────────────────────────────────┤
│  CONCLUSIÓN: El límite de velocidad NO lo impone la nave ni su masa. │
│  Lo impone la frecuencia máxima a la que el sustrato puede actualizar│
│  sus nodos. La nave no viaja: la red transmite su estado topológico. │
└─────────────────────────────────────────────────────────────────────┘
"""
ax4.text(0.5, 0.5, resumen, fontfamily='monospace', fontsize=11,
         ha='center', va='center', bbox=dict(boxstyle='round', facecolor='#f8fafc', edgecolor='#cbd5e1'))

plt.tight_layout()
plt.savefig('TCDS_Limite_Velocidad_Red_Discreta.png', dpi=300, bbox_inches='tight')
plt.show()

print("="*70)
print("DEMOSTRACIÓN COMPLETA — TCDS vs Física Convencional")
print("="*70)
print("")
print("FÍSICA CLÁSICA / RELATIVIDAD ESPECIAL:")
print("  • Masa se desplaza → requiere energía ∝ 1/√(1-v²/c²) → INFINITA en v→c")
print("  • Inercia → aceleración gradual → fuerzas G → tiempo de viaje largo")
print("  • Límite: v < c por energía, no por causalidad")
print("")
print("TCDS — RED DISCRETA:")
print("  • Estado se propaga → no hay traslación de masa → SIN inercia")
print("  • Costo: fricción topológica φ ≈ 1.618 → FINITO en cualquier velocidad")
print("  • Límite: v ≤ c por K_RATE = c/L_min → causalidad estricta, sin paradojas")
print("  • Aceleración: instantánea → Δt = 1/K_RATE ≈ 3.34e-24 s")
print("")
print("CONCLUSIÓN FINAL:")
print("El warp deja de ser un problema de energía y se convierte en un")
print("problema de ingeniería topológica: ¿puedes sincronizar la red")
print("lo suficientemente rápido para mantener el perfil LI(x) asimétrico?")
print("="*70)
