Matter as Topological Defects: Vortex Stability

Demonstrating the stability of solitons in the superfluid vacuum.

1. Objective

To computationally verify if the Dynamic Background (modeled as a superfluid via the Gross-Pitaevskii equation) is capable of sustaining stable localized structures (“particles”) without dissipating into the medium.

2. Methodology

• Mathematical Model: Dimensionless Gross-Pitaevskii Equation (GPE) with a non-linear interaction term (\(g|\Psi|^2\)).
• Numerical Method: Split-Step Fourier (Spectral Method) to ensure norm conservation and stability.
• Stabilization Technique: An initial Imaginary Time Evolution (\(t \to -it\)) was applied to cool the system and find the numerical ground state, eliminating spurious shockwaves.
• Initial Condition: A vortex with topological charge \(Q=1\) (Singular Phase Ansatz).

3. Results & Interpretation

The simulation below visualizes the evolution of the field \(\Psi\):

• Density (Left Panel): A perfectly defined “hole” or zero-density core is observed in the center of the fluid. The structure remains stable over time, resisting collapse or diffusion.
• Phase (Right Panel): An azimuthal phase gradient pattern (“pinwheel”) converging into a central singularity is visible. This confirms the topological nature of the defect.

4. Conclusion

The simulation demonstrates that matter can emerge as a stable topological defect (soliton) within the Dynamic Background. This validates Postulate 2.1 of the Theoretical Framework: matter does not need to be introduced as an external body but is a knotted configuration of the vacuum itself.

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from IPython.display import HTML  

# --- 1. CONFIGURACIÓN ---
N = 128
L = 30.0
dt = 0.005
dt_im = 0.005
g = 2.0
rho_0 = 1.0

x = np.linspace(-L/2, L/2, N)
y = np.linspace(-L/2, L/2, N)
X, Y = np.meshgrid(x, y)
dx = x[1] - x[0]
k = 2 * np.pi * np.fft.fftfreq(N, d=dx)
KX, KY = np.meshgrid(k, k)
K2 = KX**2 + KY**2

# Potencial de trampa suave
R_grid = np.sqrt(X**2 + Y**2)
V_trap = 0.5 * (R_grid / (0.45*L))**10
V_trap[V_trap > 100] = 100

# --- 2. CONDICIÓN INICIAL ---
Theta = np.arctan2(Y, X)
xi = 1.0 / np.sqrt(g * rho_0)
Psi = np.sqrt(rho_0) * np.tanh(R_grid / (2.0 * xi)) * np.exp(1j * Theta)

# --- 3. RELAJACIÓN (TIEMPO IMAGINARIO) ---
U_kin_im = np.exp(-(K2 / 2.0) * dt_im)

for i in range(100): 
    density = np.abs(Psi)**2
    Psi = Psi * np.exp(-(V_trap + g * density) * (dt_im / 2))
    Psi_k = np.fft.fft2(Psi)
    Psi_k *= U_kin_im
    Psi = np.fft.ifft2(Psi_k)
    density = np.abs(Psi)**2
    Psi = Psi * np.exp(-(V_trap + g * density) * (dt_im / 2))
    norm_factor = np.sqrt(rho_0) / np.max(np.abs(Psi))
    Psi *= norm_factor
    Psi = np.abs(Psi) * np.exp(1j * Theta)

# --- 4. EVOLUCIÓN REAL Y ANIMACIÓN ---
U_kin_real = np.exp(-1j * (K2 / 2.0) * dt)

def evolution_step_real(psi_in):
    psi_mod = psi_in * np.exp(-1j * (V_trap + g * np.abs(psi_in)**2) * (dt / 2))
    psi_k = np.fft.fft2(psi_mod)
    psi_k *= U_kin_real
    psi_mod = np.fft.ifft2(psi_k)
    psi_out = psi_mod * np.exp(-1j * (V_trap + g * np.abs(psi_mod)**2) * (dt / 2))
    return psi_out

# Configuración de la figura para la web
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5))
plt.close() # <--- IMPORTANTE: Evita que se muestre una imagen estática vacía antes de la animación

im1 = ax1.imshow(np.abs(Psi)**2, extent=[-L/2, L/2, -L/2, L/2], cmap='inferno')
ax1.set_title("Density")
im2 = ax2.imshow(np.angle(Psi), extent=[-L/2, L/2, -L/2, L/2], cmap='hsv')
ax2.set_title("Phase")

def update(frame):
    global Psi
    for _ in range(5):
        Psi = evolution_step_real(Psi)
    im1.set_data(np.abs(Psi)**2)
    im2.set_data(np.angle(Psi))
    return im1, im2

# Generar la animación
ani = animation.FuncAnimation(fig, update, frames=60, interval=50, blit=True)

# RENDERIZAR COMO VIDEO HTML5 (Base64 incrustado)
from IPython.display import HTML
display(HTML(ani.to_html5_video()))
plt.close()