import numpy as np import matplotlib.pyplot as plt from matplotlib.animation import FuncAnimation from mpl_toolkits.mplot3d import Axes3D import plotly.graph_objects as go import pandas as pd import json import os # Constants c = 299792458 # Speed of light in m/s E_mc2 = c**2 # Mass-energy equivalence in J/kg TSR = E_mc2 / (1.38e-23) # Temperature to Speed Ratio in K/m/s alpha = 1.0 # Proportional constant for TSR Q = 2 ** (1 / 12) # Fractal structure parameter dark_energy_density = 5.96e-27 # Density of dark energy in kg/m^3 dark_matter_density = 2.25e-27 # Density of dark matter in kg/m^3 collision_distance = 1e-10 # Distance for collision detection Hubble_constant = 70.0 # km/s/Mpc (approximation) Hubble_constant_SI = ( Hubble_constant * 1000 / 3.086e22 ) # Hubble constant in SI units (s^-1) # Initial conditions temperature_initial = 1.42e32 # Planck temperature in K particle_density_initial = 5.16e96 # Planck density in kg/m^3 particle_speed_initial = c # Initially at the speed of light # Simulation time t_planck = 5.39e-44 # Planck time in s t_simulation = t_planck * 1e3 # Shorter timescale for simulation # Quark masses (in GeV) - used for initial mass values and comparison quark_masses = { "up": 2.3e-3, "down": 4.8e-3, "charm": 1.28, "strange": 0.095, "top": 173.0, "bottom": 4.18, } # Conversion factor from GeV to J GeV_to_J = 1.60217662e-10 # Simulation setup num_steps = int(t_simulation / t_planck) # Tunneling probabilities to investigate tunneling_probabilities = np.arange(0.1, 1.1, 0.1) # Exclude 1.0 # Create a directory to store the data data_dir = "big_bang_simulation_data" os.makedirs(data_dir, exist_ok=True) # Functions to incorporate relativistic effects def relativistic_energy(particle_speed, particle_mass): if particle_speed >= c: return np.inf return particle_mass * c**2 / np.sqrt(max(1e-10, 1 - (particle_speed / c) ** 2)) def relativistic_momentum(particle_speed, particle_mass): if particle_speed >= c: return np.inf return ( particle_mass * particle_speed / np.sqrt(max(1e-10, 1 - (particle_speed / c) ** 2)) ) def update_speed(current_speed, current_temperature, particle_mass): rel_momentum = relativistic_momentum(current_speed, particle_mass) return c * np.sqrt( max(1e-10, 1 - (rel_momentum / (rel_momentum + dark_energy_density)) ** 2) ) # Simulate the Big Bang with Dark Energy, Dark Matter, Tunneling, and Relativistic Effects correlation_matrices = [] # Initialize correlation_matrices list for tunneling_probability in tunneling_probabilities: print(f"Running simulation for tunneling probability: {tunneling_probability}") # Initialize arrays for simulation particle_speeds = np.zeros((len(quark_masses), num_steps)) # 2D array for speeds particle_temperatures = np.zeros( (len(quark_masses), num_steps) ) # 2D array for temperatures particle_masses_evolution = np.zeros( (len(quark_masses), num_steps) ) # 2D array for mass evolution particle_positions = np.zeros( (len(quark_masses), num_steps) ) # 2D array for positions tunneling_steps = np.zeros( (len(quark_masses), num_steps), dtype=bool ) # 2D array for tunneling steps # Create an array of masses for each quark particle_masses = np.array([mass * GeV_to_J for mass in quark_masses.values()]) for j, (quark, mass) in enumerate(quark_masses.items()): particle_masses_evolution[j, 0] = particle_masses[j] # Initialize mass particle_positions[j, 0] = 0 # Initialize position for i in range(1, num_steps): particle_speeds[j, i] = update_speed( particle_speeds[j, i - 1], particle_temperatures[j, i - 1], particle_masses[j], ) particle_positions[j, i] = ( particle_positions[j, i - 1] + particle_speeds[j, i] * t_planck ) # Update position value = ( 1 - (particle_speeds[j, i] / (TSR * temperature_initial)) + dark_matter_density ) if np.random.rand() < tunneling_probability: particle_speeds[j, i] = particle_speeds[j, 0] # Tunneling effect tunneling_steps[j, i] = True # Mark tunneling step if value < 0: value = 0 particle_temperatures[j, i] = ( alpha * particle_speeds[j, i] ** 2 ) # Apply TSR equation # Update mass based on energy conversion speed_squared_diff = ( particle_speeds[j, i] ** 2 - particle_speeds[j, i - 1] ** 2 ) # Avoid division by zero (if speed doesn't change, mass doesn't change) if speed_squared_diff == 0: particle_masses_evolution[j, i] = particle_masses_evolution[j, i - 1] else: # Calculate the change in relativistic energy energy_diff = relativistic_energy( particle_speeds[j, i], particle_masses[j] ) - relativistic_energy(particle_speeds[j, i - 1], particle_masses[j]) # Avoid NaN by checking if energy_diff is practically zero if abs(energy_diff) < 1e-15: # Adjust the tolerance as needed particle_masses_evolution[j, i] = particle_masses_evolution[ j, i - 1 ] else: # Update mass based on energy difference new_mass = ( particle_masses_evolution[j, i - 1] + energy_diff / c**2 ) if np.isfinite(new_mass): # Check if the new mass is finite particle_masses_evolution[j, i] = new_mass else: particle_masses_evolution[j, i] = particle_masses_evolution[ j, i - 1 ] # Collision detection and resolution for k in range(j + 1, len(quark_masses)): if ( abs(particle_positions[j, i] - particle_positions[k, i]) < collision_distance ): # Resolve collision (simplified example) # Calculate relative speed before the collision v_rel = particle_speeds[j, i] - particle_speeds[k, i] # Calculate the new speeds after the collision particle_speeds[j, i] = ( particle_speeds[j, i] * (particle_masses[j] - particle_masses[k]) + 2 * particle_masses[k] * particle_speeds[k, i] ) / (particle_masses[j] + particle_masses[k]) particle_speeds[k, i] = ( particle_speeds[k, i] * (particle_masses[k] - particle_masses[j]) + 2 * particle_masses[j] * particle_speeds[j, i] ) / (particle_masses[j] + particle_masses[k]) # Limit speed after collision max_speed = c * 0.99 # Adjust the maximum speed as needed particle_speeds[j, i] = np.clip(particle_speeds[j, i], 0, max_speed) particle_speeds[k, i] = np.clip(particle_speeds[k, i], 0, max_speed) # Update temperatures based on TSR particle_temperatures[j, i] = alpha * particle_speeds[j, i] ** 2 particle_temperatures[k, i] = alpha * particle_speeds[k, i] ** 2 # Apply expansion of the universe (redshift) particle_speeds[j, i] *= 1 - Hubble_constant_SI * t_planck # Apply expansion of the universe (cooling) particle_temperatures[j, i] *= 1 - Hubble_constant_SI * t_planck # Debugging output if np.isnan(particle_speeds[j, i]) or np.isnan(particle_temperatures[j, i]): print(f"NaN detected at step {i} for quark {quark}") print(f"Previous speed: {particle_speeds[j, i - 1]}") print(f"Previous temperature: {particle_temperatures[j, i - 1]}") print(f"Current speed: {particle_speeds[j, i]}") print(f"Current temperature: {particle_temperatures[j, i]}") break # Cap speed to avoid unphysical values particle_speeds[j] = np.clip(particle_speeds[j], 0, c) # --- Plotly Interactive Visualization (3D) --- # Create the 3D scatter plot using Plotly fig = go.Figure( data=[ go.Scatter3d( x=particle_speeds[j], y=particle_temperatures[j], z=np.arange(num_steps), mode="lines+markers", name=quark.capitalize(), ) for j, quark in enumerate(quark_masses.keys()) ] ) fig.update_layout( title=f"Big Bang Simulation: Temperature vs. Speed (Tunneling Probability: {tunneling_probability})", autosize=False, width=800, height=600, margin=dict(l=65, r=50, b=65, t=90), ) fig.show() # --- Matplotlib Animation (3D) --- fig = plt.figure() ax = fig.add_subplot(111, projection="3d") (line,) = ax.plot([], [], [], "b-") # Set axis limits ax.set_xlim(min(particle_speeds.flatten()), max(particle_speeds.flatten())) ax.set_ylim( min(particle_temperatures.flatten()), max(particle_temperatures.flatten()) ) ax.set_zlim(0, num_steps) ax.set_xlabel("Particle Speed") ax.set_ylabel("Particle Temperature") ax.set_zlabel("Time") ax.set_title( f"Big Bang Simulation Animation (Tunneling Probability: {tunneling_probability})" ) def init(): line.set_data([], []) line.set_3d_properties([]) return (line,) def update(frame): line.set_data( particle_speeds[:, :frame].flatten(), particle_temperatures[:, :frame].flatten(), ) line.set_3d_properties(np.tile(np.arange(frame), len(quark_masses))) return (line,) ani = FuncAnimation(fig, update, frames=num_steps, init_func=init, blit=True) ani.save(f"big_bang_simulation_3d_{tunneling_probability}.gif", writer="pillow") plt.show() # --- Plotly Mass Evolution (3D) --- X, Y = np.meshgrid( particle_speeds[0], np.arange(num_steps) ) # Create 2D meshgrid for x and y fig = go.Figure( data=[ go.Surface( z=particle_masses_evolution[j], x=X, y=Y, colorscale="Viridis", name=quark.capitalize(), ) for j, quark in enumerate(quark_masses.keys()) ] ) fig.update_layout( title=f"Big Bang Simulation: Mass Evolution (Tunneling Probability: {tunneling_probability})", autosize=False, width=800, height=600, margin=dict(l=65, r=50, b=65, t=90), ) fig.show() # --- Plotly Tunneling Effect (3D) --- X, Y = np.meshgrid( particle_speeds[0], np.arange(num_steps) ) # Create 2D meshgrid for x and y fig = go.Figure( data=[ go.Surface( z=tunneling_steps[j], x=X, y=Y, colorscale="Blues", name=quark.capitalize(), ) for j, quark in enumerate(quark_masses.keys()) ] ) fig.update_layout( title=f"Big Bang Simulation: Tunneling Effect (Tunneling Probability: {tunneling_probability})", autosize=False, width=800, height=600, margin=dict(l=65, r=50, b=65, t=90), ) fig.show() # --- Correlation Analysis --- df = pd.DataFrame( { "Speed": particle_speeds.flatten(), "Temperature": particle_temperatures.flatten(), "Mass": particle_masses_evolution.flatten(), "Tunneling": tunneling_steps.flatten(), } ) correlation_matrix = df.corr() correlation_matrices.append(correlation_matrix) print("Correlation Matrix:") print(correlation_matrix) # Print calculated masses at the end of the simulation print( f"Calculated masses at the end of the simulation (Tunneling Probability: {tunneling_probability}):" ) for j, quark in enumerate(quark_masses.keys()): print(f"{quark}: {particle_masses_evolution[j, -1] / GeV_to_J:.4e} GeV") print("Real masses:") for quark, mass in quark_masses.items(): print(f"{quark}: {mass:.4e} GeV") # Save data to JSON file data_filename = os.path.join( data_dir, f"big_bang_simulation_data_{tunneling_probability:.1f}.json" ) data = { "tunneling_probability": tunneling_probability, "particle_speeds": particle_speeds.tolist(), "particle_temperatures": particle_temperatures.tolist(), "particle_masses_evolution": particle_masses_evolution.tolist(), "tunneling_steps": tunneling_steps.tolist(), "correlation_matrix": correlation_matrix.values.tolist(), # Use values.tolist() to convert DataFrame to list } with open(data_filename, "w") as f: json.dump(data, f) correlation_matrices = [] for tunneling_probability in tunneling_probabilities: #... (rest of the code remains the same) correlation_matrix = df.corr() if correlation_matrix.shape[0] == correlation_matrix.shape[1]: correlation_matrices.append(correlation_matrix) else: print(f"Skipping correlation matrix for tunneling probability {tunneling_probability} because it is not a square matrix.") # Flatten the correlation matrices flat_correlation_matrices = [] for i, matrix in enumerate(correlation_matrices): flattened = matrix.values.flatten() flat_correlation_matrices.append(flattened) # Convert to 2D array flat_correlation_matrices = np.array(flat_correlation_matrices) # Create DataFrame with appropriate column names columns = [f"Corr_{i}_{j}" for i in range(flat_correlation_matrices.shape[1] // 4) for j in range(4)] correlation_matrices_df = pd.DataFrame(flat_correlation_matrices, columns=columns, index=tunneling_probabilities) # Print or save DataFrame print("Correlation Matrices for Different Tunneling Probabilities:") print(correlation_matrices_df)