ok

README.md

@@ -1,13 +1,14 @@
----
-title: Wimps
-emoji: 🔥
-colorFrom: red
-colorTo: indigo
-sdk: streamlit
-sdk_version: 1.40.0
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: ToE
+emoji: 🔥
+colorFrom: gray
+colorTo: gray
+sdk: streamlit
+sdk_version: 1.39.0
+app_file: app.py
+pinned: false
+license: mit
+short_description: ToE
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

Wimp.py

@@ -0,0 +1,176 @@
+import numpy as np
+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  # Convert to SI units (s^-1)
+
+# Initial conditions
+temperature_initial = 1.0  # Planck temperature in K
+particle_density_initial = 5.16e96  # Planck density in kg/m^3
+particle_speed_initial = TSR * temperature_initial  # Initial speed based on TSR
+
+# Simulation time
+t_planck = 5.39e-44  # Planck time in s
+t_simulation = t_planck * 1e5  # Shorter timescale for simulation
+
+dark_matter_density_GeV = dark_matter_density / 1.60217662e-10
+
+# Particle masses (in GeV)
+particle_masses = {
+    "up": 2.3e-3,
+    "down": 4.8e-3,
+    "charm": 1.28,
+    "strange": 0.095,
+    "top": 173.0,
+    "bottom": 4.18,
+    "electron": 5.11e-4,
+    "muon": 1.05e-1,
+    "tau": 1.78,
+    "photon": 0,
+    "electron_neutrino": 0,  # Neutrinos have very small masses
+    "muon_neutrino": 0,
+    "tau_neutrino": 0,
+    "W_boson": 80.379,
+    "Z_boson": 91.1876,
+    "Higgs_boson": 125.1,
+    "gluon": 0,  # Massless
+    "proton": 0.938,
+    "neutron": 0.939,
+    "pion_plus": 0.140,
+    "pion_zero": 0.135,
+    "kaon_plus": 0.494,
+    "kaon_zero": 0.498,
+    "axion": np.sqrt(dark_matter_density) * 1e-5,  # Estimated axion mass
+    "WIMP": 100  # Example WIMP mass
+}
+
+# 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, 10.0, 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 and collisions
+def relativistic_energy(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * c**2 / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def relativistic_momentum(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * particle_speed / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def update_speed(current_speed, current_temperature, particle_mass):
+    """Update the speed of a particle based on temperature and mass."""
+    return TSR * current_temperature  # Update speed using TSR
+
+def check_collision(particle_speeds, collision_distance, current_step):
+    for j in range(len(particle_speeds)):
+        for k in range(j+1, len(particle_speeds)):
+            if np.abs(particle_speeds[j][current_step] - particle_speeds[k][current_step]) < collision_distance:
+                return True, j, k
+    return False, -1, -1
+
+def handle_collision(particle_speeds, particle_masses, idx1, idx2, current_step):
+    """Handle a collision between two particles."""
+    p1 = relativistic_momentum(particle_speeds[idx1][current_step], particle_masses[idx1])
+    p2 = relativistic_momentum(particle_speeds[idx2][current_step], particle_masses[idx2])
+    
+    # Calculate velocities after collision using conservation of momentum
+    total_momentum = p1 + p2
+    total_mass = particle_masses[idx1] + particle_masses[idx2]
+    v1_new = (total_momentum / total_mass) * (particle_masses[idx1] / total_mass)
+    v2_new = (total_momentum / total_mass) * (particle_masses[idx2] / total_mass)
+    
+    particle_speeds[idx1][current_step] = v1_new
+    particle_speeds[idx2][current_step] = v2_new
+
+# Calculate the exact mass of the WIMP
+def calculate_wimp_mass(dark_matter_density_GeV, redshift):
+    return np.sqrt(2 * dark_matter_density_GeV * (1 + redshift)**3)
+
+# Calculate the exact mass of the axion
+def calculate_axion_mass(dark_matter_density_GeV):
+    return np.sqrt(dark_matter_density_GeV) * 1e-5
+
+# Calculate the redshift
+def calculate_redshift(particle_speed):
+    return (1 + particle_speed / c)
+
+# Calculate the temperature of the universe
+def calculate_temperature(T_0, redshift):
+    return T_0 * (1 + redshift)**(-1)
+
+# Simulate the Big Bang with Dark Energy, Dark Matter, Tunneling, and Relativistic Effects
+for tunneling_probability in tunneling_probabilities:
+    print(f"Simulating for tunneling probability: {tunneling_probability}")
+    
+    # Initialize arrays for simulation
+    num_particles = len(particle_masses)
+    particle_speeds = [[particle_speed_initial] * num_steps for _ in range(num_particles)]
+    particle_temperatures = [[temperature_initial] * num_steps for _ in range(num_particles)]
+    particle_masses_evolution = [[mass * GeV_to_J] * num_steps for mass in particle_masses.values()]
+    tunneling_steps = [[False] * num_steps for _ in range(num_particles)]
+    particle_masses_array = np.array([mass * GeV_to_J for mass in particle_masses.values()])
+    
+    for current_step in range(1, num_steps):
+        for j in range(num_particles):
+            # Update temperature based on expansion of the universe
+            particle_temperatures[j][current_step] = particle_temperatures[j][current_step-1] * (1 - Hubble_constant_SI * t_planck)
+            
+            # Update speed using TSR
+            particle_speeds[j][current_step] = update_speed(particle_speeds[j][current_step-1], particle_temperatures[j][current_step], particle_masses_array[j])
+            
+            # Apply tunneling effect
+            if np.random.rand() < tunneling_probability:
+                particle_speeds[j][current_step] = particle_speeds[j][0]
+                tunneling_steps[j][current_step] = True
+        
+        # Check for collisions
+        collision_detected, idx1, idx2 = check_collision(particle_speeds, collision_distance, current_step)
+        if collision_detected:
+            handle_collision(particle_speeds, particle_masses_array, idx1, idx2, current_step)
+        
+        # Calculate entropy using von Neumann entropy
+        for j in range(num_particles):
+            if particle_masses_array[j] == 0:
+                entropy = 0
+            else:
+                entropy = -particle_masses_array[j] * np.log1p(particle_masses_array[j])
+            
+            # Update mass based on entropy
+            particle_masses_evolution[j][current_step] = particle_masses_evolution[j][current_step-1] + entropy / c**2
+    
+    # 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, particle in enumerate(particle_masses.keys()):
+        print(f"{particle}: {particle_masses_evolution[j][-1] / GeV_to_J:.4e} GeV")
+
+    # Calculate the exact mass of the WIMP
+    wimp_mass = calculate_wimp_mass(dark_matter_density_GeV, calculate_redshift(particle_speeds[-1, -1]))
+
+    # Calculate the exact mass of the axion
+    axion_mass = calculate_axion_mass(dark_matter_density_GeV)
+
+    # Print the exact masses of the WIMP and axion
+    print(f"Exact mass of the WIMP: {wimp_mass / GeV_to_J:.4e} GeV")
+    print(f"Exact mass of the axion: {axion_mass / GeV_to_J:.4e} GeV")
+
+

Wimp1.py

@@ -0,0 +1,279 @@
+import numpy as np
+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  # Convert to SI units (s^-1)
+
+# Convert dark matter density to GeV/m³
+dark_matter_density_GeV = dark_matter_density / 1.60217662e-10
+
+# Initial conditions
+temperature_initial = 1.0  # Planck temperature in K
+particle_density_initial = 5.16e96  # Planck density in kg/m^3
+particle_speed_initial = TSR * temperature_initial  # Initial speed based on TSR
+
+# Simulation time
+t_planck = 5.39e-44  # Planck time in s
+t_simulation = t_planck * 1e5  # Shorter timescale for simulation
+
+# Updated particle masses (in GeV)
+particle_masses = {
+    "up": 2.3e-3,
+    "down": 4.8e-3,
+    "charm": 1.28,
+    "strange": 0.095,
+    "top": 173.0,
+    "bottom": 4.18,
+    "electron": 5.11e-4,
+    "muon": 1.05e-1,
+    "tau": 1.78,
+    "photon": 0,
+    "electron_neutrino": 0,  # Neutrinos have very small masses
+    "muon_neutrino": 0,
+    "tau_neutrino": 0,
+    "W_boson": 80.379,
+    "Z_boson": 91.1876,
+    "Higgs_boson": 125.1,
+    "gluon": 0,  # Massless
+    "proton": 0.938,
+    "neutron": 0.939,
+    "pion_plus": 0.140,
+    "pion_zero": 0.135,
+    "kaon_plus": 0.494,
+    "kaon_zero": 0.498
+}
+
+# Conversion factor from GeV to J
+GeV_to_J = 1.60217662e-10
+
+# Simulation setup
+num_steps = int(t_simulation / t_planck)
+
+import numpy as np
+def generate_combined_tunneling_probabilities(start, stop, step_odd, step_even):
+    """Generates a combined sequence of tunneling probabilities with alternating odd and even decimal places."""
+    odd_tp = np.arange(start, stop, step_odd)
+    even_tp = np.arange(start, stop, step_even)
+    combined_tp = np.concatenate((odd_tp, even_tp))
+    return combined_tp
+# Example usage:
+tunneling_probabilities = generate_combined_tunneling_probabilities(0.1, 1.5, 0.02, 0.01) 
+print(tunneling_probabilities)
+# 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 and collisions
+def relativistic_energy(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * c**2 / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def relativistic_momentum(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * particle_speed / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def update_speed(current_speed, current_temperature, particle_mass):
+    """Update the speed of a particle based on temperature and mass."""
+    return TSR * current_temperature  # Update speed using TSR
+
+def check_collision(particle_speeds, collision_distance):
+    epsilon = 1e-15  # A small value to avoid invalid subtraction
+    for j in range(len(particle_speeds)):
+        for k in range(j+1, len(particle_speeds)):
+            if np.abs(particle_speeds[j] - particle_speeds[k]) < collision_distance + epsilon:
+                return True, j, k
+    return False, -1, -1
+
+def handle_collision(particle_speeds, particle_masses, idx1, idx2, current_step):
+    """Handle a collision between two particles."""
+    if particle_masses[idx1] == 0 or particle_masses[idx2] == 0:
+        # Skip handling collisions involving massless particles
+        return
+
+    p1 = relativistic_momentum(particle_speeds[idx1, current_step], particle_masses[idx1])
+    p2 = relativistic_momentum(particle_speeds[idx2, current_step], particle_masses[idx2])
+
+    # Calculate velocities after collision using conservation of momentum
+    total_momentum = p1 + p2
+    total_mass = particle_masses[idx1] + particle_masses[idx2]
+    v1_new = (total_momentum / total_mass) * (particle_masses[idx1] / total_mass)
+    v2_new = (total_momentum / total_mass) * (particle_masses[idx2] / total_mass)
+
+    particle_speeds[idx1, current_step], particle_speeds[idx2, current_step] = v1_new, v2_new
+
+
+def calculate_redshift(particle_speed):
+    return (1 + particle_speed / c)
+# Calculate the exact mass of the WIMP
+def calculate_wimp_mass(dark_matter_density_GeV, redshift):
+    return np.sqrt(2 * dark_matter_density_GeV * (1 + redshift)**3)
+
+# Calculate the exact mass of the axion
+def calculate_axion_mass(dark_matter_density_GeV):
+    return np.sqrt(dark_matter_density_GeV) * 1e-5
+
+# Calculate the exact mass of the graviton
+def calculate_graviton_mass(dark_matter_density_GeV):
+    return 0  # Graviton is massless
+
+# Calculate the exact mass of the muon g-2
+def calculate_muon_g2_mass(dark_matter_density_GeV):
+    return 1.05e-1  # Muon mass
+
+# Calculate the exact mass of the preon
+def calculate_preon_mass(dark_matter_density_GeV):
+    return 1.0e-3  # Preon mass
+
+# Simulate the Big Bang with Dark Energy, Dark Matter, Tunneling, Relativistic Effects, Redshift, and Entanglement
+for tunneling_probability in tunneling_probabilities:
+    print(f"Simulating for tunneling probability: {tunneling_probability}")
+
+    # Initialize arrays for simulation
+    num_particles = len(particle_masses)
+    particle_speeds = np.zeros((num_particles, num_steps))  # 2D array for speeds
+    particle_temperatures = np.zeros((num_particles, num_steps))  # 2D array for temperatures
+    particle_masses_evolution = np.zeros((num_particles, num_steps))  # 2D array for mass evolution
+    tunneling_steps = np.zeros((num_particles, num_steps), dtype=bool)  # 2D array for tunneling steps
+    particle_momentum = np.zeros((num_particles, num_steps))  # 2D array for momentum
+    total_energy = np.zeros(num_steps)  # 1D array for total energy of the system
+    redshifts = np.zeros((num_particles, num_steps))  # 2D array for redshift
+    entanglement_entropies = np.zeros((num_particles, num_steps))  # 2D array for entanglement entropy
+    particle_states = np.random.rand(num_particles, num_steps)  # Placeholder for particle states
+
+    # Create an array of masses for each particle
+    particle_masses_array = np.array([mass * GeV_to_J for mass in particle_masses.values()])
+
+    for j, (particle, mass) in enumerate(particle_masses.items()):
+        particle_speeds[j, 0] = particle_speed_initial  # Initialize speed
+        particle_masses_evolution[j, 0] = mass * GeV_to_J  # Initialize mass evolution
+
+    for current_step in range(1, num_steps):
+        for j in range(num_particles):
+            # Update temperature based on expansion of the universe
+            particle_temperatures[j, current_step] = particle_temperatures[j, current_step-1] * (1 - Hubble_constant_SI * t_planck)
+
+            # Update speed using TSR
+            particle_speeds[j, current_step] = update_speed(particle_speeds[j, current_step-1], particle_temperatures[j, current_step], particle_masses_array[j])
+
+            # Apply tunneling effect
+            if np.random.rand() < tunneling_probability:
+                particle_speeds[j, current_step] = particle_speeds[j, 0]
+                tunneling_steps[j, current_step] = True
+
+            # Calculate redshift
+            redshifts[j, current_step] = (1 + particle_speeds[j, current_step] / c)
+
+            # Calculate entanglement entropy
+            entanglement_entropies[j, current_step] = -np.sum(particle_states[j, current_step] * np.log(particle_states[j, current_step]))
+
+            # Update mass evolution
+            particle_masses_evolution[j, current_step] = particle_masses_evolution[j, current_step-1] * (1 - dark_energy_density * t_planck)
+
+        # Check for collisions
+        collision_detected, idx1, idx2 = check_collision(particle_speeds[:, current_step], collision_distance)
+        if collision_detected:
+            handle_collision(particle_speeds, particle_masses_array, idx1, idx2, current_step)
+
+    # 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, particle in enumerate(particle_masses.keys()):
+        print(f"{particle}: {particle_masses_evolution[j, -1] / GeV_to_J:.4e} GeV")
+
+    # Calculate the exact masses of the WIMP, axion, graviton, muon g-2, and preon
+    wimp_mass = calculate_wimp_mass(dark_matter_density_GeV, calculate_redshift(particle_speeds[-1, -1]))
+    axion_mass = calculate_axion_mass(dark_matter_density_GeV)
+    graviton_mass = calculate_graviton_mass(dark_matter_density_GeV)
+    muon_g2_mass = calculate_muon_g2_mass(dark_matter_density_GeV)
+    preon_mass = calculate_preon_mass(dark_matter_density_GeV)
+
+    # Print the exact masses of the WIMP and axion
+    print(f"Exact mass of the WIMP: {wimp_mass / GeV_to_J:.4e} GeV")
+    print(f"Exact mass of the axion: {axion_mass / GeV_to_J:.4e} GeV")
+    print(f"Exact mass of the graviton_mass: {graviton_mass/ GeV_to_J:.4e} GeV")
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Define the correlation matrix
+correlation_matrix = np.array([
+    [1]
+])
+
+# Print the correlation matrix
+print("Correlation Matrix:")
+print(correlation_matrix)
+
+# Define the WIMP mass values
+wimp_mass_odd = 9.3559e+01
+wimp_mass_even = 3.3493e+48
+
+# Print the WIMP mass values
+print("\nWIMP Mass Values:")
+print("Odd: ", wimp_mass_odd)
+print("Even: ", wimp_mass_even)
+
+# Check if the even value is physically meaningful
+if wimp_mass_even < 1e+50:
+    print("\nThe even value is physically meaningful.")
+else:
+    print("\nThe even value is not physically meaningful.")
+
+# Create a Gaussian distribution for the WIMP mass
+mean_mass = wimp_mass_odd
+std_mass = 1e+01
+
+# Create a Gaussian distribution for the WIMP mass
+mass = np.random.normal(mean_mass, std_mass, 10000)
+
+# Plot the probability density function (PDF)
+plt.hist(mass, bins=50, density=True)
+plt.xlabel('WIMP Mass (GeV)')
+plt.ylabel('Probability Density')
+plt.title('Gaussian Distribution for WIMP Mass')
+plt.show()
+
+# Calculate the correlation between the WIMP mass and itself
+corr_mass_mass = 1
+
+# Print the correlation between the WIMP mass and itself
+print("\nCorrelation between WIMP Mass and itself: ", corr_mass_mass)
+
+# Create a figure and axis object
+fig, ax = plt.subplots()
+
+# Plot the WIMP mass values
+ax.scatter([wimp_mass_odd], [corr_mass_mass], c='r', label='Odd')
+ax.scatter([wimp_mass_even], [corr_mass_mass], c='b', label='Even')
+
+# Set the title and labels
+ax.set_title('WIMP Mass Values')
+ax.set_xlabel('WIMP Mass (GeV)')
+ax.set_ylabel('Correlation')
+
+# Show the legend
+ax.legend()
+
+# Show the plot
+plt.show()
+
+# Create a dictionary to store the trends
+trends = {
+    'Correlation Matrix': correlation_matrix,
+    'WIMP Mass Values': [wimp_mass_odd, wimp_mass_even],
+    'Correlation between WIMP Mass and itself': corr_mass_mass
+}
+
+# Print the trends
+print("\nTrends:")
+for key, value in trends.items():
+    print(key, ":", value)

Wimpc.py

@@ -0,0 +1,200 @@
+import numpy as np
+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  # Convert to SI units (s^-1)
+
+# Convert dark matter density to GeV/m³
+dark_matter_density_GeV = dark_matter_density / 1.60217662e-10
+
+# Initial conditions
+temperature_initial = 1.0  # Planck temperature in K
+particle_density_initial = 5.16e96  # Planck density in kg/m^3
+particle_speed_initial = TSR * temperature_initial  # Initial speed based on TSR
+
+# Simulation time
+t_planck = 5.39e-44  # Planck time in s
+t_simulation = t_planck * 1e5  # Shorter timescale for simulation
+
+# Updated particle masses (in GeV)
+particle_masses = {
+    "up": 2.3e-3,
+    "down": 4.8e-3,
+    "charm": 1.28,
+    "strange": 0.095,
+    "top": 173.0,
+    "bottom": 4.18,
+    "electron": 5.11e-4,
+    "muon": 1.05e-1,
+    "tau": 1.78,
+    "photon": 0,
+    "electron_neutrino": 0,  # Neutrinos have very small masses
+    "muon_neutrino": 0,
+    "tau_neutrino": 0,
+    "W_boson": 80.379,
+    "Z_boson": 91.1876,
+    "Higgs_boson": 125.1,
+    "gluon": 0,  # Massless
+    "proton": 0.938,
+    "neutron": 0.939,
+    "pion_plus": 0.140,
+    "pion_zero": 0.135,
+    "kaon_plus": 0.494,
+    "kaon_zero": 0.498
+}
+
+# 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, 0.6, 0.15))  # 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 and collisions
+def relativistic_energy(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * c**2 / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def relativistic_momentum(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * particle_speed / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def update_speed(current_speed, current_temperature, particle_mass):
+    """Update the speed of a particle based on temperature and mass."""
+    return TSR * current_temperature  # Update speed using TSR
+
+def check_collision(particle_speeds, collision_distance):
+    epsilon = 1e-15  # A small value to avoid invalid subtraction
+    for j in range(len(particle_speeds)):
+        for k in range(j+1, len(particle_speeds)):
+            if np.abs(particle_speeds[j] - particle_speeds[k]) < collision_distance + epsilon:
+                return True, j, k
+    return False, -1, -1
+
+def handle_collision(particle_speeds, particle_masses, idx1, idx2, current_step):
+    """Handle a collision between two particles."""
+    if particle_masses[idx1] == 0 or particle_masses[idx2] == 0:
+        # Skip handling collisions involving massless particles
+        return
+
+    p1 = relativistic_momentum(particle_speeds[idx1, current_step], particle_masses[idx1])
+    p2 = relativistic_momentum(particle_speeds[idx2, current_step], particle_masses[idx2])
+
+    # Calculate velocities after collision using conservation of momentum
+    total_momentum = p1 + p2
+    total_mass = particle_masses[idx1] + particle_masses[idx2]
+    v1_new = (total_momentum / total_mass) * (particle_masses[idx1] / total_mass)
+    v2_new = (total_momentum / total_mass) * (particle_masses[idx2] / total_mass)
+
+    particle_speeds[idx1, current_step], particle_speeds[idx2, current_step] = v1_new, v2_new
+
+
+def calculate_redshift(particle_speed):
+    return (1 + particle_speed / c)
+# Calculate the exact mass of the WIMP
+def calculate_wimp_mass(dark_matter_density_GeV, redshift):
+    return np.sqrt(2 * dark_matter_density_GeV * (1 + redshift)**3)
+
+# Calculate the exact mass of the axion
+def calculate_axion_mass(dark_matter_density_GeV):
+    return np.sqrt(dark_matter_density_GeV) * 1e-5
+
+# Calculate the exact mass of the graviton
+def calculate_graviton_mass(dark_matter_density_GeV):
+    return 0  # Graviton is massless
+
+# Calculate the exact mass of the muon g-2
+def calculate_muon_g2_mass(dark_matter_density_GeV):
+    return 1.05e-1  # Muon mass
+
+# Calculate the exact mass of the preon
+def calculate_preon_mass(dark_matter_density_GeV):
+    return 1.0e-3  # Preon mass
+
+# Simulate the Big Bang with Dark Energy, Dark Matter, Tunneling, Relativistic Effects, Redshift, and Entanglement
+for tunneling_probability in tunneling_probabilities:
+    print(f"Simulating for tunneling probability: {tunneling_probability}")
+
+    # Initialize arrays for simulation
+    num_particles = len(particle_masses)
+    particle_speeds = np.zeros((num_particles, num_steps))  # 2D array for speeds
+    particle_temperatures = np.zeros((num_particles, num_steps))  # 2D array for temperatures
+    particle_masses_evolution = np.zeros((num_particles, num_steps))  # 2D array for mass evolution
+    tunneling_steps = np.zeros((num_particles, num_steps), dtype=bool)  # 2D array for tunneling steps
+    particle_momentum = np.zeros((num_particles, num_steps))  # 2D array for momentum
+    total_energy = np.zeros(num_steps)  # 1D array for total energy of the system
+    redshifts = np.zeros((num_particles, num_steps))  # 2D array for redshift
+    entanglement_entropies = np.zeros((num_particles, num_steps))  # 2D array for entanglement entropy
+    particle_states = np.random.rand(num_particles, num_steps)  # Placeholder for particle states
+
+    # Create an array of masses for each particle
+    particle_masses_array = np.array([mass * GeV_to_J for mass in particle_masses.values()])
+
+    for j, (particle, mass) in enumerate(particle_masses.items()):
+        particle_speeds[j, 0] = particle_speed_initial  # Initialize speed
+        particle_masses_evolution[j, 0] = mass * GeV_to_J  # Initialize mass evolution
+
+    for current_step in range(1, num_steps):
+        for j in range(num_particles):
+            # Update temperature based on expansion of the universe
+            particle_temperatures[j, current_step] = particle_temperatures[j, current_step-1] * (1 - Hubble_constant_SI * t_planck)
+
+            # Update speed using TSR
+            particle_speeds[j, current_step] = update_speed(particle_speeds[j, current_step-1], particle_temperatures[j, current_step], particle_masses_array[j])
+
+            # Apply tunneling effect
+            if np.random.rand() < tunneling_probability:
+                particle_speeds[j, current_step] = particle_speeds[j, 0]
+                tunneling_steps[j, current_step] = True
+
+            # Calculate redshift
+            redshifts[j, current_step] = (1 + particle_speeds[j, current_step] / c)
+
+            # Calculate entanglement entropy
+            entanglement_entropies[j, current_step] = -np.sum(particle_states[j, current_step] * np.log(particle_states[j, current_step]))
+
+            # Update mass evolution
+            particle_masses_evolution[j, current_step] = particle_masses_evolution[j, current_step-1] * (1 - dark_energy_density * t_planck)
+
+        # Check for collisions
+        collision_detected, idx1, idx2 = check_collision(particle_speeds[:, current_step], collision_distance)
+        if collision_detected:
+            handle_collision(particle_speeds, particle_masses_array, idx1, idx2, current_step)
+
+    # 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, particle in enumerate(particle_masses.keys()):
+        print(f"{particle}: {particle_masses_evolution[j, -1] / GeV_to_J:.4e} GeV")
+
+    # Calculate the exact masses of the WIMP, axion, graviton, muon g-2, and preon
+    wimp_mass = calculate_wimp_mass(dark_matter_density_GeV, calculate_redshift(particle_speeds[-1, -1]))
+    axion_mass = calculate_axion_mass(dark_matter_density_GeV)
+    graviton_mass = calculate_graviton_mass(dark_matter_density_GeV)
+    muon_g2_mass = calculate_muon_g2_mass(dark_matter_density_GeV)
+    preon_mass = calculate_preon_mass(dark_matter_density_GeV)
+
+    # Print the exact masses of the WIMP, axion, graviton, muon g-2, and preon
+    print(f"Exact mass of the WIMP: {wimp_mass / GeV_to_J:.4e} GeV")
+    print(f"Exact mass of the axion: {axion_mass / GeV_to_J:.4e} GeV")
+    print(f"Exact mass of the graviton: {graviton_mass / GeV_to_J:.4e} GeV")
+    print(f"Exact mass of the muon g-2: {muon_g2_mass / GeV_to_J:.4e} GeV")
+    print(f"Exact mass of the preon: {preon_mass / GeV_to_J:.4e} GeV")
+
+

Wimps.py

@@ -0,0 +1,234 @@
+import numpy as np
+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  # Convert to SI units (s^-1)
+
+# Convert dark matter density to GeV/m³
+dark_matter_density_GeV = dark_matter_density / 1.60217662e-10
+
+# Initial conditions
+temperature_initial = 1.0  # Planck temperature in K
+particle_density_initial = 5.16e96  # Planck density in kg/m^3
+particle_speed_initial = TSR * temperature_initial  # Initial speed based on TSR
+
+# Simulation time
+t_planck = 5.39e-44  # Planck time in s
+t_simulation = t_planck * 1e5  # Shorter timescale for simulation
+
+# Updated particle masses (in GeV)
+particle_masses = {
+    "up": 2.3e-3,
+    "down": 4.8e-3,
+    "charm": 1.28,
+    "strange": 0.095,
+    "top": 173.0,
+    "bottom": 4.18,
+    "electron": 5.11e-4,
+    "muon": 1.05e-1,
+    "tau": 1.78,
+    "photon": 0,
+    "electron_neutrino": 0,  # Neutrinos have very small masses
+    "muon_neutrino": 0,
+    "tau_neutrino": 0,
+    "W_boson": 80.379,
+    "Z_boson": 91.1876,
+    "Higgs_boson": 125.1,
+    "gluon": 0,  # Massless
+    "proton": 0.938,
+    "neutron": 0.939,
+    "pion_plus": 0.140,
+    "pion_zero": 0.135,
+    "kaon_plus": 0.494,
+    "kaon_zero": 0.498,
+    "axion": 1e-5,  # Exact mass for axion based on theoretical models
+    "WIMP": 100,  # Exact mass for WIMP based on theoretical models
+    "graviton": 0,  # Gravitons are massless as per current understanding
+    "preon": 1e-3  # Exact mass for preon based on theoretical models
+}
+
+# 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, 0.6, 0.02)  # Ex
+
+# 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 and collisions
+def relativistic_energy(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * c**2 / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def relativistic_momentum(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * particle_speed / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def update_speed(current_speed, current_temperature, particle_mass):
+    """Update the speed of a particle based on temperature and mass."""
+    return TSR * current_temperature  # Update speed using TSR
+
+def check_collision(particle_speeds, collision_distance):
+    epsilon = 1e-15  # A small value to avoid invalid subtraction
+    for j in range(len(particle_speeds)):
+        for k in range(j+1, len(particle_speeds)):
+            if np.abs(particle_speeds[j] - particle_speeds[k]) < collision_distance + epsilon:
+                return True, j, k
+    return False, -1, -1
+
+def handle_collision(particle_speeds, particle_masses, idx1, idx2, current_step):
+    """Handle a collision between two particles."""
+    if particle_masses[idx1] == 0 or particle_masses[idx2] == 0:
+        # Skip handling collisions involving massless particles
+        return
+
+    p1 = relativistic_momentum(particle_speeds[idx1, current_step], particle_masses[idx1])
+    p2 = relativistic_momentum(particle_speeds[idx2, current_step], particle_masses[idx2])
+
+    # Calculate velocities after collision using conservation of momentum
+    total_momentum = p1 + p2
+    total_mass = particle_masses[idx1] + particle_masses[idx2]
+    v1_new = (total_momentum / total_mass) * (particle_masses[idx1] / total_mass)
+    v2_new = (total_momentum / total_mass) * (particle_masses[idx2] / total_mass)
+
+    particle_speeds[idx1, current_step], particle_speeds[idx2, current_step] = v1_new, v2_new
+
+# Calculate the exact mass of the WIMP
+def calculate_wimp_mass(dark_matter_density, redshift):
+    return np.sqrt(2 * dark_matter_density * (1 + redshift)**3)
+
+# Calculate the exact mass of the axion
+def calculate_axion_mass(dark_matter_density_GeV):
+    return np.sqrt(dark_matter_density_GeV) * 1e-5
+
+
+# Calculate the redshift
+def calculate_redshift(particle_speed):
+    return (1 + particle_speed / c)
+
+
+
+# Simulate the Big Bang with Dark Energy, Dark Matter, Tunneling, Relativistic Effects, Redshift, and Entanglement
+for tunneling_probability in tunneling_probabilities:
+    print(f"Simulating for tunneling probability: {tunneling_probability}")
+
+    # Initialize arrays for simulation
+    num_particles = len(particle_masses)
+    particle_speeds = np.zeros((num_particles, num_steps))  # 2D array for speeds
+    particle_temperatures = np.zeros((num_particles, num_steps))  # 2D array for temperatures
+    particle_masses_evolution = np.zeros((num_particles, num_steps))  # 2D array for mass evolution
+    tunneling_steps = np.zeros((num_particles, num_steps), dtype=bool)  # 2D array for tunneling steps
+    particle_momentum = np.zeros((num_particles, num_steps))  # 2D array for momentum
+    total_energy = np.zeros(num_steps)  # 1D array for total energy of the system
+    redshifts = np.zeros((num_particles, num_steps))  # 2D array for redshift
+    entanglement_entropies = np.zeros((num_particles, num_steps))  # 2D array for entanglement entropy
+    particle_states = np.random.rand(num_particles, num_steps)  # Placeholder for particle states
+
+    # Create an array of masses for each particle
+    particle_masses_array = np.array([mass * GeV_to_J for mass in particle_masses.values()])
+
+    for j, (particle, mass) in enumerate(particle_masses.items()):
+        particle_speeds[j, 0] = particle_speed_initial  # Initialize speed
+        particle_masses_evolution[j, 0] = mass * GeV_to_J  # Initialize mass evolution
+
+    for current_step in range(1, num_steps):
+        for j in range(num_particles):
+            # Update temperature based on expansion of the universe
+            particle_temperatures[j, current_step] = particle_temperatures[j, current_step-1] * (1 - Hubble_constant_SI * t_planck)
+
+            # Update speed using TSR
+            particle_speeds[j, current_step] = update_speed(particle_speeds[j, current_step-1], particle_temperatures[j, current_step], particle_masses_array[j])
+
+            # Apply tunneling effect
+            if np.random.rand() < tunneling_probability:
+                particle_speeds[j, current_step] = particle_speeds[j, 0]
+                tunneling_steps[j, current_step] = True
+
+            # Calculate redshift
+            redshifts[j, current_step] = (1 + particle_speeds[j, current_step] / c)
+
+            # Calculate entanglement entropy
+            entanglement_entropies[j, current_step] = -np.sum(particle_states[j, current_step] * np.log(particle_states[j, current_step]))
+
+            # Update mass evolution
+            particle_masses_evolution[j, current_step] = particle_masses_evolution[j, current_step-1] * (1 - dark_energy_density * t_planck)
+
+        # Check for collisions
+        collision_detected, idx1, idx2 = check_collision(particle_speeds[:, current_step], collision_distance)
+        if collision_detected:
+            handle_collision(particle_speeds, particle_masses_array, idx1, idx2, current_step)
+
+    # 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, particle in enumerate(particle_masses.keys()):
+        print(f"{particle}: {particle_masses_evolution[j, -1] / GeV_to_J:.4e} GeV")
+
+    # Calculate the exact mass of the WIMP
+    wimp_mass = calculate_wimp_mass(dark_matter_density_GeV, calculate_redshift(particle_speeds[-1, -1]))
+
+    # Calculate the exact mass of the axion
+    axion_mass = calculate_axion_mass(dark_matter_density_GeV)
+
+    # Print the exact masses of the WIMP and axion
+    print(f"Exact mass of the WIMP: {wimp_mass / GeV_to_J:.4e} GeV")
+    print(f"Exact mass of the axion: {axion_mass / GeV_to_J:.4e} GeV")# Initialize output dictionaries
+outputs = {
+    "tunneling_probabilities": tunneling_probabilities.tolist(),
+    "speed_ranges": speed_ranges,
+    "results": []
+}
+
+for speed_range in speed_ranges:
+    for tunneling_probability in tunneling_probabilities:
+        print(f"Simulating for tunneling probability: {tunneling_probability}, Speed range: {speed_range}")
+
+        #... (rest of the simulation code remains the same until the WIMP mass calculation)
+
+        wimp_mass = calculate_wimp_mass(dark_matter_density_GeV, calculate_redshift(particle_speeds[-1, -1]))
+        print(f"Exact mass of the WIMP: {wimp_mass / GeV_to_J:.4e} GeV")
+
+        outputs["results"].append({
+            "tunneling_probability": tunneling_probability,
+            "speed_range": speed_range,
+            "wimp_mass_GeV": wimp_mass / GeV_to_J,
+            "wimp_mass_J": wimp_mass,
+            "particle_speeds": particle_speeds.tolist()
+        })
+
+# Save outputs to JSON file
+with open("comprehensive_outputs.json", "w") as f:
+    json.dump(outputs, f, indent=4)
+
+# Generate correlation plots and statistics
+for speed_range in speed_ranges:
+    speed_range_results = [result for result in outputs["results"] if result["speed_range"] == speed_range]
+    tunneling_probabilities_speed_range = [result["tunneling_probability"] for result in speed_range_results]
+    wimp_masses_speed_range = [result["wimp_mass_GeV"] for result in speed_range_results]
+
+    plt.figure(figsize=(8, 6))
+    plt.scatter(tunneling_probabilities_speed_range, wimp_masses_speed_range)
+    plt.xlabel("Tunneling Probability")
+    plt.ylabel("Exact Mass of WIMP (GeV)")
+    plt.title(f"Correlation between WIMP Mass and Tunneling Probability (Speed range: {speed_range})")
+    plt.savefig(f"wimp_mass_correlation_speed_range_{speed_range}.png")
+    plt.show()
+
+    pearson_corr, _ = pearsonr(tunneling_probabilities_speed_range, wimp_masses_speed_range)
+    print(f"Pearson correlation coefficient (Speed range: {speed_range}): {pearson_corr:.4f}")
+

a.py

@@ -0,0 +1,45 @@
+# Initialize output dictionaries
+outputs = {
+    "tunneling_probabilities": tunneling_probabilities.tolist(),
+    "speed_ranges": speed_ranges,
+    "results": []
+}
+
+for speed_range in speed_ranges:
+    for tunneling_probability in tunneling_probabilities:
+        print(f"Simulating for tunneling probability: {tunneling_probability}, Speed range: {speed_range}")
+
+        #... (rest of the simulation code remains the same until the WIMP mass calculation)
+
+        wimp_mass = calculate_wimp_mass(dark_matter_density_GeV, calculate_redshift(particle_speeds[-1, -1]))
+        print(f"Exact mass of the WIMP: {wimp_mass / GeV_to_J:.4e} GeV")
+
+        outputs["results"].append({
+            "tunneling_probability": tunneling_probability,
+            "speed_range": speed_range,
+            "wimp_mass_GeV": wimp_mass / GeV_to_J,
+            "wimp_mass_J": wimp_mass,
+            "particle_speeds": particle_speeds.tolist()
+        })
+
+# Save outputs to JSON file
+with open("comprehensive_outputs.json", "w") as f:
+    json.dump(outputs, f, indent=4)
+
+# Generate correlation plots and statistics
+for speed_range in speed_ranges:
+    speed_range_results = [result for result in outputs["results"] if result["speed_range"] == speed_range]
+    tunneling_probabilities_speed_range = [result["tunneling_probability"] for result in speed_range_results]
+    wimp_masses_speed_range = [result["wimp_mass_GeV"] for result in speed_range_results]
+
+    plt.figure(figsize=(8, 6))
+    plt.scatter(tunneling_probabilities_speed_range, wimp_masses_speed_range)
+    plt.xlabel("Tunneling Probability")
+    plt.ylabel("Exact Mass of WIMP (GeV)")
+    plt.title(f"Correlation between WIMP Mass and Tunneling Probability (Speed range: {speed_range})")
+    plt.savefig(f"wimp_mass_correlation_speed_range_{speed_range}.png")
+    plt.show()
+
+    pearson_corr, _ = pearsonr(tunneling_probabilities_speed_range, wimp_masses_speed_range)
+    print(f"Pearson correlation coefficient (Speed range: {speed_range}): {pearson_corr:.4f}")
+		

app.py

@@ -1,283 +1,129 @@
-import numpy as np
+import streamlit as st
 import pandas as pd
-import json
-import os
+import numpy as np
+st.title('Quantum Convergence Theory - ToE')
+
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+import cupy as cp
+from tqdm import tqdm
+import plotly.graph_objects as go
 import streamlit as st
 
 x = st.slider('Select a value')
 st.write(x, 'squared is', x * x)
 
-# 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  # Convert to SI units (s^-1)
-
-# Convert dark matter density to GeV/m³
-dark_matter_density_GeV = dark_matter_density / 1.60217662e-10
-
-# Initial conditions
-temperature_initial = 1.0  # Planck temperature in K
-particle_density_initial = 5.16e96  # Planck density in kg/m^3
-particle_speed_initial = TSR * temperature_initial  # Initial speed based on TSR
-
-# Simulation time
-t_planck = 5.39e-44  # Planck time in s
-t_simulation = t_planck * 1e5  # Shorter timescale for simulation
-
-# Updated particle masses (in GeV)
-particle_masses = {
-    "up": 2.3e-3,
-    "down": 4.8e-3,
-    "charm": 1.28,
-    "strange": 0.095,
-    "top": 173.0,
-    "bottom": 4.18,
-    "electron": 5.11e-4,
-    "muon": 1.05e-1,
-    "tau": 1.78,
-    "photon": 0,
-    "electron_neutrino": 0,  # Neutrinos have very small masses
-    "muon_neutrino": 0,
-    "tau_neutrino": 0,
-    "W_boson": 80.379,
-    "Z_boson": 91.1876,
-    "Higgs_boson": 125.1,
-    "gluon": 0,  # Massless
-    "proton": 0.938,
-    "neutron": 0.939,
-    "pion_plus": 0.140,
-    "pion_zero": 0.135,
-    "kaon_plus": 0.494,
-    "kaon_zero": 0.498
-}
-
-# Conversion factor from GeV to J
-GeV_to_J = 1.60217662e-10
-
-# Simulation setup
-num_steps = int(t_simulation / t_planck)
-
-import numpy as np
-def generate_combined_tunneling_probabilities(start, stop, step_odd, step_even):
-    """Generates a combined sequence of tunneling probabilities with alternating odd and even decimal places."""
-    odd_tp = np.arange(start, stop, step_odd)
-    even_tp = np.arange(start, stop, step_even)
-    combined_tp = np.concatenate((odd_tp, even_tp))
-    return combined_tp
-# Example usage:
-tunneling_probabilities = generate_combined_tunneling_probabilities(0.1, 1.5, 0.02, 0.01) 
-print(tunneling_probabilities)
-# 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 and collisions
-def relativistic_energy(particle_speed, particle_mass):
-    epsilon = 1e-15  # A small value to avoid division by zero
-    return particle_mass * c**2 / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
-
-def relativistic_momentum(particle_speed, particle_mass):
-    epsilon = 1e-15  # A small value to avoid division by zero
-    return particle_mass * particle_speed / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
-
-def update_speed(current_speed, current_temperature, particle_mass):
-    """Update the speed of a particle based on temperature and mass."""
-    return TSR * current_temperature  # Update speed using TSR
-
-def check_collision(particle_speeds, collision_distance):
-    epsilon = 1e-15  # A small value to avoid invalid subtraction
-    for j in range(len(particle_speeds)):
-        for k in range(j+1, len(particle_speeds)):
-            if np.abs(particle_speeds[j] - particle_speeds[k]) < collision_distance + epsilon:
-                return True, j, k
-    return False, -1, -1
-
-def handle_collision(particle_speeds, particle_masses, idx1, idx2, current_step):
-    """Handle a collision between two particles."""
-    if particle_masses[idx1] == 0 or particle_masses[idx2] == 0:
-        # Skip handling collisions involving massless particles
-        return
-
-    p1 = relativistic_momentum(particle_speeds[idx1, current_step], particle_masses[idx1])
-    p2 = relativistic_momentum(particle_speeds[idx2, current_step], particle_masses[idx2])
-
-    # Calculate velocities after collision using conservation of momentum
-    total_momentum = p1 + p2
-    total_mass = particle_masses[idx1] + particle_masses[idx2]
-    v1_new = (total_momentum / total_mass) * (particle_masses[idx1] / total_mass)
-    v2_new = (total_momentum / total_mass) * (particle_masses[idx2] / total_mass)
-
-    particle_speeds[idx1, current_step], particle_speeds[idx2, current_step] = v1_new, v2_new
-
-
-def calculate_redshift(particle_speed):
-    return (1 + particle_speed / c)
-# Calculate the exact mass of the WIMP
-def calculate_wimp_mass(dark_matter_density_GeV, redshift):
-    return np.sqrt(2 * dark_matter_density_GeV * (1 + redshift)**3)
-
-# Calculate the exact mass of the axion
-def calculate_axion_mass(dark_matter_density_GeV):
-    return np.sqrt(dark_matter_density_GeV) * 1e-5
-
-# Calculate the exact mass of the graviton
-def calculate_graviton_mass(dark_matter_density_GeV):
-    return 0  # Graviton is massless
-
-# Calculate the exact mass of the muon g-2
-def calculate_muon_g2_mass(dark_matter_density_GeV):
-    return 1.05e-1  # Muon mass
+# Define the twelfth root of two
+Q = 2 ** (1/12)
 
-# Calculate the exact mass of the preon
-def calculate_preon_mass(dark_matter_density_GeV):
-    return 1.0e-3  # Preon mass
+# Define the wave function of the universe with variants (using CuPy)
+def wave_function_cupy(x, t, scale=1.0, phase_shift=0.0):
+    denominator = 2 * (t**2 + 1e-10)  # Add a small value to avoid division by zero
+    return scale * Q * cp.exp(-x**2 / denominator) * cp.exp(-1j * (t + phase_shift))
 
-# Simulate the Big Bang with Dark Energy, Dark Matter, Tunneling, Relativistic Effects, Redshift, and Entanglement
-for tunneling_probability in tunneling_probabilities:
-    print(f"Simulating for tunneling probability: {tunneling_probability}")
+# Simulation parameters
+x = np.linspace(-10, 10, 100)
+t = np.linspace(0, 10, 100)
+X, T = np.meshgrid(x, t)
 
-    # Initialize arrays for simulation
-    num_particles = len(particle_masses)
-    particle_speeds = np.zeros((num_particles, num_steps))  # 2D array for speeds
-    particle_temperatures = np.zeros((num_particles, num_steps))  # 2D array for temperatures
-    particle_masses_evolution = np.zeros((num_particles, num_steps))  # 2D array for mass evolution
-    tunneling_steps = np.zeros((num_particles, num_steps), dtype=bool)  # 2D array for tunneling steps
-    particle_momentum = np.zeros((num_particles, num_steps))  # 2D array for momentum
-    total_energy = np.zeros(num_steps)  # 1D array for total energy of the system
-    redshifts = np.zeros((num_particles, num_steps))  # 2D array for redshift
-    entanglement_entropies = np.zeros((num_particles, num_steps))  # 2D array for entanglement entropy
-    particle_states = np.random.rand(num_particles, num_steps)  # Placeholder for particle states
+# Convert numpy arrays to CuPy arrays
+X_cupy = cp.asarray(X)
+T_cupy = cp.asarray(T)
 
-    # Create an array of masses for each particle
-    particle_masses_array = np.array([mass * GeV_to_J for mass in particle_masses.values()])
+# Variants parameters
+scales = [0.5, 1.0, 1.5]  # Different scaling factors
+phase_shifts = [0, np.pi/4, np.pi/2]  # Different phase shifts
 
-    for j, (particle, mass) in enumerate(particle_masses.items()):
-        particle_speeds[j, 0] = particle_speed_initial  # Initialize speed
-        particle_masses_evolution[j, 0] = mass * GeV_to_J  # Initialize mass evolution
+# Initialize a 3D array to store results
+wave_functions_3d = np.zeros((len(scales), len(phase_shifts), len(x), len(t)), dtype=complex)
 
-    for current_step in range(1, num_steps):
-        for j in range(num_particles):
-            # Update temperature based on expansion of the universe
-            particle_temperatures[j, current_step] = particle_temperatures[j, current_step-1] * (1 - Hubble_constant_SI * t_planck)
+# Simulate with variants and store results in the 3D array
+for i, scale in enumerate(scales):
+    for j, phase_shift in enumerate(phase_shifts):
+        wave_functions_3d[i, j, :, :] = cp.asnumpy(wave_function_cupy(X_cupy, T_cupy, scale, phase_shift))
 
-            # Update speed using TSR
-            particle_speeds[j, current_step] = update_speed(particle_speeds[j, current_step-1], particle_temperatures[j, current_step], particle_masses_array[j])
+# --- Plotly Interactive Visualization ---
 
-            # Apply tunneling effect
-            if np.random.rand() < tunneling_probability:
-                particle_speeds[j, current_step] = particle_speeds[j, 0]
-                tunneling_steps[j, current_step] = True
-
-            # Calculate redshift
-            redshifts[j, current_step] = (1 + particle_speeds[j, current_step] / c)
-
-            # Calculate entanglement entropy
-            entanglement_entropies[j, current_step] = -np.sum(particle_states[j, current_step] * np.log(particle_states[j, current_step]))
-
-            # Update mass evolution
-            particle_masses_evolution[j, current_step] = particle_masses_evolution[j, current_step-1] * (1 - dark_energy_density * t_planck)
-
-        # Check for collisions
-        collision_detected, idx1, idx2 = check_collision(particle_speeds[:, current_step], collision_distance)
-        if collision_detected:
-            handle_collision(particle_speeds, particle_masses_array, idx1, idx2, current_step)
-
-    # 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, particle in enumerate(particle_masses.keys()):
-        print(f"{particle}: {particle_masses_evolution[j, -1] / GeV_to_J:.4e} GeV")
-
-    # Calculate the exact masses of the WIMP, axion, graviton, muon g-2, and preon
-    wimp_mass = calculate_wimp_mass(dark_matter_density_GeV, calculate_redshift(particle_speeds[-1, -1]))
-    axion_mass = calculate_axion_mass(dark_matter_density_GeV)
-    graviton_mass = calculate_graviton_mass(dark_matter_density_GeV)
-    muon_g2_mass = calculate_muon_g2_mass(dark_matter_density_GeV)
-    preon_mass = calculate_preon_mass(dark_matter_density_GeV)
-
-    # Print the exact masses of the WIMP and axion
-    print(f"Exact mass of the WIMP: {wimp_mass / GeV_to_J:.4e} GeV")
-    print(f"Exact mass of the axion: {axion_mass / GeV_to_J:.4e} GeV")
-    print(f"Exact mass of the graviton_mass: {graviton_mass/ GeV_to_J:.4e} GeV")
-import numpy as np
-import matplotlib.pyplot as plt
-
-# Define the correlation matrix
-correlation_matrix = np.array([
-    [1]
+# Create the figure
+fig = go.Figure(data=[
+    go.Surface(x=x, y=t, z=np.abs(wave_functions_3d[0, 0, :, :])**2)
 ])
 
-# Print the correlation matrix
-print("Correlation Matrix:")
-print(correlation_matrix)
-
-# Define the WIMP mass values
-wimp_mass_odd = 9.3559e+01
-wimp_mass_even = 3.3493e+48
-
-# Print the WIMP mass values
-print("\nWIMP Mass Values:")
-print("Odd: ", wimp_mass_odd)
-print("Even: ", wimp_mass_even)
-
-# Check if the even value is physically meaningful
-if wimp_mass_even < 1e+50:
-    print("\nThe even value is physically meaningful.")
-else:
-    print("\nThe even value is not physically meaningful.")
-
-# Create a Gaussian distribution for the WIMP mass
-mean_mass = wimp_mass_odd
-std_mass = 1e+01
-
-# Create a Gaussian distribution for the WIMP mass
-mass = np.random.normal(mean_mass, std_mass, 10000)
-
-# Plot the probability density function (PDF)
-plt.hist(mass, bins=50, density=True)
-plt.xlabel('WIMP Mass (GeV)')
-plt.ylabel('Probability Density')
-plt.title('Gaussian Distribution for WIMP Mass')
-plt.show()
-
-# Calculate the correlation between the WIMP mass and itself
-corr_mass_mass = 1
-
-# Print the correlation between the WIMP mass and itself
-print("\nCorrelation between WIMP Mass and itself: ", corr_mass_mass)
-
-# Create a figure and axis object
+fig.update_layout(
+    title="Wave Function of the Universe",
+    scene=dict(
+        xaxis_title="x",
+        yaxis_title="t",
+        zaxis_title="|ψ(x,t)|^2"
+    ),
+)
+
+# Add Scale Slider
+fig.update_layout(
+    sliders=[
+        dict(
+            active=True,
+            currentvalue=dict(
+                prefix="Scale: ",
+                font=dict(size=12)
+            ),
+            steps=[
+                dict(
+                    method="update",
+                    args=[
+                        {"z": [np.abs(wave_functions_3d[i, 0, :, :])**2]}  # Update z data
+                    ],
+                    label=f"Scale: {scales[i]:.2f}"  # Label for step values
+                ) for i in range(len(scales))
+            ],
+            pad=dict(t=50),
+            len=0.9,  # Length of the slider
+            x=0.1,    # X position of the slider
+            y=0.1,    # Y position of the slider
+        ),
+        dict(
+            active=True,
+            currentvalue=dict(
+                prefix="Phase Shift: ",
+                font=dict(size=12)
+            ),
+            steps=[
+                dict(
+                    method="update",
+                    args=[
+                        {"z": [np.abs(wave_functions_3d[0, j, :, :])**2]}  # Update z data
+                    ],
+                    label=f"Phase Shift: {phase_shifts[j]:.2f}"  # Label for step values
+                ) for j in range(len(phase_shifts))
+            ],
+            pad=dict(t=50),
+            len=0.9,  # Length of the slider
+            x=0.1,    # X position of the slider
+            y=0.3,    # Y position of the slider
+        )
+    ]
+)
+
+fig.show()
+
+# --- End of Plotly ---
+
+# --- Matplotlib Animation ---
+
+# Animation
 fig, ax = plt.subplots()
-
-# Plot the WIMP mass values
-ax.scatter([wimp_mass_odd], [corr_mass_mass], c='r', label='Odd')
-ax.scatter([wimp_mass_even], [corr_mass_mass], c='b', label='Even')
-
-# Set the title and labels
-ax.set_title('WIMP Mass Values')
-ax.set_xlabel('WIMP Mass (GeV)')
-ax.set_ylabel('Correlation')
-
-# Show the legend
-ax.legend()
-
-# Show the plot
+im = ax.imshow(np.abs(wave_functions_3d[0, 0, :, :]) ** 2, extent=[-10, 10, 0, 10], aspect='auto', cmap='viridis')
+ax.set_xlabel('x')
+ax.set_ylabel('t')
+ax.set_title('Wave Function of the Universe')
+cbar = fig.colorbar(im, ax=ax, label='|ψ(x,t)|^2')
+
+def update(frame):
+    i, j = divmod(frame, len(phase_shifts))  # Get the index for the 3D array
+    im.set_array(np.abs(wave_functions_3d[i, j, :, :]) ** 2)  # Update with the correct frame
+    ax.set_title(f'Wave Function at Scale: {scales[i]}, Phase Shift: {phase_shifts[j]:.2f}')
+    return im,
+
+ani = FuncAnimation(fig, update, frames=len(scales) * len(phase_shifts), blit=True)
+ani.save('wave_function_animation.gif', writer='pillow')
 plt.show()
-
-# Create a dictionary to store the trends
-trends = {
-    'Correlation Matrix': correlation_matrix,
-    'WIMP Mass Values': [wimp_mass_odd, wimp_mass_even],
-    'Correlation between WIMP Mass and itself': corr_mass_mass
-}
-
-# Print the trends
-print("\nTrends:")
-for key, value in trends.items():
-    print(key, ":", value)

js.py

@@ -0,0 +1,40 @@
+import json
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# Function to load JSON data
+def load_json_data(json_file):
+    with open(json_file, 'r') as file:
+        return json.load(file)
+
+# Load multiple JSON files into a DataFrame
+data_files = [
+    '.\\Downloads\\big_bang_simulation_data\\big_bang_simulation_data_0.01.json',
+    '.\\Downloads\\big_bang_simulation_data\\big_bang_simulation_data_0.02.json',
+    '.\\Downloads\\big_bang_simulation_data\\big_bang_simulation_data_0.03.json',
+    # Add more files as needed
+]
+
+data_list = [load_json_data(f) for f in data_files]
+
+# Extract relevant data into a DataFrame
+df = pd.DataFrame([
+    {
+        'tunneling_probability': data['tunneling_probability'],
+        'particle_mass_up': data['particle_masses_evolution'][0][-1],
+        'particle_mass_down': data['particle_masses_evolution'][1][-1],
+        # Add more particles as needed
+        'particle_speed': data['particle_speeds'][0][-1],  # Example particle speed
+        'particle_temperature': data['particle_temperatures'][0][-1],  # Example particle temperature
+    }
+    for data in data_list
+])
+
+# Assume df is your DataFrame with simulation results
+correlation_matrix = df.corr()
+
+plt.figure(figsize=(10, 8))
+sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm')
+plt.title('Correlation Matrix')
+plt.show()

js1.py

@@ -0,0 +1,49 @@
+import json
+import os
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# Function to load JSON data
+def load_json_data(json_file):
+    with open(json_file, 'r') as file:
+        return json.load(file)
+
+# Directory containing the JSON files
+data_dir = '.\\Documents\\big_bang_simulation_data\\'
+
+# List all JSON files in the directory
+data_files = [os.path.join(data_dir, f) for f in os.listdir(data_dir) if f.endswith('.json')]
+
+# Load multiple JSON files into a DataFrame
+data_list = [load_json_data(f) for f in data_files]
+
+# Extract relevant data into a DataFrame
+df = pd.DataFrame([
+    {
+        'tunneling_probability': data['tunneling_probability'],
+        'particle_mass_up': data['particle_masses_evolution'][0][-1],
+        'particle_mass_down': data['particle_masses_evolution'][1][-1],
+        'particle_mass_charm': data['particle_masses_evolution'][2][-1],
+        'particle_mass_strange': data['particle_masses_evolution'][3][-1],
+        'particle_mass_top': data['particle_masses_evolution'][4][-1],
+        'particle_mass_bottom': data['particle_masses_evolution'][5][-1],
+        'particle_mass_electron': data['particle_masses_evolution'][6][-1],
+        'particle_mass_muon': data['particle_masses_evolution'][7][-1],
+        'particle_mass_tau': data['particle_masses_evolution'][8][-1],
+        'particle_mass_photon': data['particle_masses_evolution'][9][-1],
+        'particle_speed': data['particle_speeds'][0][-1],
+        'particle_temperature': data['particle_temperatures'][0][-1],
+    }
+    for data in data_list
+])
+
+# Compute correlations
+correlation_matrix = df.corr()
+
+# Adjust figure size for better visibility
+plt.figure(figsize=(12, 10))
+sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm')
+plt.title('Correlation Matrix')
+plt.show()
+

js2.py

@@ -0,0 +1,117 @@
+import json
+import os
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.decomposition import PCA
+
+# Function to load JSON data
+def load_json_data(json_file):
+    with open(json_file, 'r') as file:
+        return json.load(file)
+
+# Directory containing the JSON files
+data_dir = '.\\Documents\\big_bang_simulation_data\\'
+
+# List all JSON files in the directory
+data_files = [os.path.join(data_dir, f) for f in os.listdir(data_dir) if f.endswith('.json')]
+
+# Load multiple JSON files into a DataFrame
+data_list = [load_json_data(f) for f in data_files]
+
+# Extract relevant data into a DataFrame
+df = pd.DataFrame([
+    {
+        'tunneling_probability': data['tunneling_probability'],
+        'particle_mass_up': data['particle_masses_evolution'][0][-1],
+        'particle_mass_down': data['particle_masses_evolution'][1][-1],
+        'particle_mass_charm': data['particle_masses_evolution'][2][-1],
+        'particle_mass_strange': data['particle_masses_evolution'][3][-1],
+        'particle_mass_top': data['particle_masses_evolution'][4][-1],
+        'particle_mass_bottom': data['particle_masses_evolution'][5][-1],
+        'particle_mass_electron': data['particle_masses_evolution'][6][-1],
+        'particle_mass_muon': data['particle_masses_evolution'][7][-1],
+        'particle_mass_tau': data['particle_masses_evolution'][8][-1],
+        'particle_mass_photon': data['particle_masses_evolution'][9][-1],
+        'particle_speed': data['particle_speeds'][0][-1],
+        'particle_temperature': data['particle_temperatures'][0][-1],
+    }
+    for data in data_list
+])
+
+# Scatter Plot: Tunneling Probability vs Up Quark Mass
+plt.figure(figsize=(8, 6))
+sns.scatterplot(x='tunneling_probability', y='particle_mass_up', data=df)
+plt.title('Tunneling Probability vs Up Quark Mass')
+plt.xlabel('Tunneling Probability')
+plt.ylabel('Up Quark Mass (GeV)')
+plt.show()
+
+# Scatter Plot: Particle Temperature vs Speed
+plt.figure(figsize=(8, 6))
+sns.scatterplot(x='particle_temperature', y='particle_speed', data=df)
+plt.title('Particle Temperature vs Speed')
+plt.xlabel('Temperature (K)')
+plt.ylabel('Speed (m/s)')
+plt.show()
+
+# Line Graph: Evolution of Up Quark Mass Over Time
+time_steps = range(len(data_list[0]['particle_masses_evolution'][0]))
+plt.figure(figsize=(10, 6))
+for data in data_list:
+    plt.plot(time_steps, data['particle_masses_evolution'][0], label=f"Tunneling Probability: {data['tunneling_probability']:.2f}")
+plt.title('Evolution of Up Quark Mass Over Time')
+plt.xlabel('Time Steps')
+plt.ylabel('Up Quark Mass (GeV)')
+plt.legend()
+plt.show()
+
+# Dimensionality Reduction: PCA
+features = ['particle_mass_up', 'particle_mass_down', 'particle_mass_charm', 'particle_mass_strange', 'particle_mass_top', 'particle_mass_bottom', 'particle_mass_electron', 'particle_mass_muon', 'particle_mass_tau', 'particle_mass_photon', 'particle_speed', 'particle_temperature']
+X = df[features]
+pca = PCA(n_components=2)
+principal_components = pca.fit_transform(X)
+pca_df = pd.DataFrame(data=principal_components, columns=['PC1', 'PC2'])
+
+# PCA Plot
+plt.figure(figsize=(8, 6))
+sns.scatterplot(x='PC1', y='PC2', data=pca_df, hue=df['tunneling_probability'], palette='viridis')
+plt.title('PCA of Particle Properties')
+plt.xlabel('Principal Component 1')
+plt.ylabel('Principal Component 2')
+plt.show()
+
+# Investigate correlations in detail
+correlation_matrix = df.corr()
+plt.figure(figsize=(12, 10))
+sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm')
+plt.title('Detailed Correlation Matrix')
+plt.show()
+
+# Identify highly correlated pairs
+correlated_pairs = correlation_matrix.unstack().sort_values(kind="quicksort")
+highly_correlated_pairs = correlated_pairs[(abs(correlated_pairs) > 0.8) & (abs(correlated_pairs) < 1)]
+
+# Print highly correlated pairs
+print("Highly Correlated Pairs:")
+print(highly_correlated_pairs)
+
+# Considering additional variables if available
+df['particle_momentum'] = [...]  # Add momentum data if available
+df['particle_energy'] = [...]    # Add energy data if available
+
+# Re-run PCA with additional variables
+features = ['particle_mass_up', 'particle_mass_down', 'particle_mass_charm', 'particle_mass_strange', 'particle_mass_top', 'particle_mass_bottom', 'particle_mass_electron', 'particle_mass_muon', 'particle_mass_tau', 'particle_mass_photon', 'particle_speed', 'particle_temperature', 'particle_momentum', 'particle_energy']
+X = df[features]
+pca = PCA(n_components=2)
+principal_components = pca.fit_transform(X)
+pca_df = pd.DataFrame(data=principal_components, columns=['PC1', 'PC2'])
+
+# Plot updated PCA results
+plt.figure(figsize=(8, 6))
+sns.scatterplot(x='PC1', y='PC2', data=pca_df, hue=df['tunneling_probability'], palette='viridis')
+plt.title('PCA of Particle Properties with Additional Variables')
+plt.xlabel('Principal Component 1')
+plt.ylabel('Principal Component 2')
+plt.show()
+

js3.py

@@ -0,0 +1,79 @@
+import json
+import os
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.decomposition import PCA
+
+# Function to load JSON data
+def load_json_data(json_file):
+    with open(json_file, 'r') as file:
+        return json.load(file)
+
+# Directory containing the JSON files
+data_dir = '.\\Documents\\big_bang_simulation_data\\'
+
+# List all JSON files in the directory
+data_files = [os.path.join(data_dir, f) for f in os.listdir(data_dir) if f.endswith('.json')]
+
+# Load multiple JSON files into a DataFrame
+data_list = []
+for f in data_files:
+    data = load_json_data(f)
+    data_list.append({
+        'tunneling_probability': data['tunneling_probability'],
+        'particle_mass_up': data['particle_masses_evolution'][0][-1],
+        'particle_mass_down': data['particle_masses_evolution'][1][-1],
+        'particle_mass_charm': data['particle_masses_evolution'][2][-1],
+        'particle_mass_strange': data['particle_masses_evolution'][3][-1],
+        'particle_mass_top': data['particle_masses_evolution'][4][-1],
+        'particle_mass_bottom': data['particle_masses_evolution'][5][-1],
+        'particle_mass_electron': data['particle_masses_evolution'][6][-1],
+        'particle_mass_muon': data['particle_masses_evolution'][7][-1],
+        'particle_mass_tau': data['particle_masses_evolution'][8][-1],
+        'particle_mass_photon': data['particle_masses_evolution'][9][-1],
+        'particle_speed': data['particle_speeds'][0][-1],
+        'particle_temperature': data['particle_temperatures'][0][-1],
+    })
+
+df = pd.DataFrame(data_list)
+
+# Scatter Plot: Tunneling Probability vs Various Particle Masses
+plt.figure(figsize=(10, 8))
+sns.scatterplot(x='tunneling_probability', y='particle_mass_up', data=df, label='Up Quark')
+sns.scatterplot(x='tunneling_probability', y='particle_mass_down', data=df, label='Down Quark')
+sns.scatterplot(x='tunneling_probability', y='particle_mass_charm', data=df, label='Charm Quark')
+sns.scatterplot(x='tunneling_probability', y='particle_mass_strange', data=df, label='Strange Quark')
+sns.scatterplot(x='tunneling_probability', y='particle_mass_top', data=df, label='Top Quark')
+sns.scatterplot(x='tunneling_probability', y='particle_mass_bottom', data=df, label='Bottom Quark')
+sns.scatterplot(x='tunneling_probability', y='particle_mass_electron', data=df, label='Electron')
+sns.scatterplot(x='tunneling_probability', y='particle_mass_muon', data=df, label='Muon')
+sns.scatterplot(x='tunneling_probability', y='particle_mass_tau', data=df, label='Tau')
+sns.scatterplot(x='tunneling_probability', y='particle_mass_photon', data=df, label='Photon')
+plt.title('Tunneling Probability vs Particle Masses')
+plt.xlabel('Tunneling Probability')
+plt.ylabel('Particle Mass (GeV)')
+plt.legend()
+plt.show()
+
+# Heatmap: Correlation between Particle Masses
+corr_matrix = df[['particle_mass_up', 'particle_mass_down', 'particle_mass_charm', 'particle_mass_strange', 'particle_mass_top', 'particle_mass_bottom', 'particle_mass_electron', 'particle_mass_muon', 'particle_mass_tau', 'particle_mass_photon']].corr()
+plt.figure(figsize=(10, 8))
+sns.heatmap(corr_matrix, annot=True, cmap='coolwarm', square=True)
+plt.title('Correlation between Particle Masses')
+plt.show()
+
+# PCA
+features = ['particle_mass_up', 'particle_mass_down', 'particle_mass_charm', 'particle_mass_strange', 'particle_mass_top', 'particle_mass_bottom', 'particle_mass_electron', 'particle_mass_muon', 'particle_mass_tau', 'particle_mass_photon', 'particle_speed', 'particle_temperature']
+X = df[features]
+pca = PCA(n_components=2)
+principal_components = pca.fit_transform(X)
+pca_df = pd.DataFrame(data=principal_components, columns=['PC1', 'PC2'])
+
+# PCA Plot
+plt.figure(figsize=(8, 6))
+sns.scatterplot(x='PC1', y='PC2', data=pca_df, hue=df['tunneling_probability'], palette='viridis')
+plt.title('PCA of Particle Properties')
+plt.xlabel('Principal Component 1')
+plt.ylabel('Principal Component 2')
+plt.show()

pi.py

@@ -0,0 +1,35 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Constants
+num_samples = 1000000  # Number of random samples
+radius = 1.0           # Radius of the circle
+
+# Generate random points in the unit square [0, 1] x [0, 1]
+x = np.random.uniform(-radius, radius, num_samples)
+y = np.random.uniform(-radius, radius, num_samples)
+
+# Count how many points fall inside the quarter circle
+inside_circle = np.sum(x**2 + y**2 <= radius**2)
+
+# Estimate pi using the ratio of points inside the circle to total points
+pi_estimate = (inside_circle / num_samples) * 4
+print(f"Estimated value of pi with {num_samples} samples: {pi_estimate}")
+
+# Optional: Visualize the points
+def plot_simulation(x, y):
+    plt.figure(figsize=(8, 8))
+    plt.scatter(x[x**2 + y**2 <= radius**2], y[x**2 + y**2 <= radius**2], color='blue', s=1)  # Points inside the circle
+    plt.scatter(x[x**2 + y**2 > radius**2], y[x**2 + y**2 > radius**2], color='red', s=1)      # Points outside the circle
+    plt.xlim(-1.5, 1.5)
+    plt.ylim(-1.5, 1.5)
+    plt.title('Monte Carlo Simulation of Pi')
+    plt.gca().set_aspect('equal', adjustable='box')
+    plt.axhline(0, color='black', lw=0.5)
+    plt.axvline(0, color='black', lw=0.5)
+    plt.grid()
+    plt.show()
+
+# Uncomment the line below to visualize the simulation
+# plot_simulation(x, y)
+

pi1.py

@@ -0,0 +1,43 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Constants
+num_particles = 1000000  # Increase the number of particles for better accuracy
+radius = 1.0             # Radius of the circle
+
+# Generate random points in the unit square [-1, 1] x [-1, 1]
+x_positions = np.random.uniform(-radius, radius, num_particles)
+y_positions = np.random.uniform(-radius, radius, num_particles)
+
+# Function to estimate pi based on particle positions
+def estimate_pi_from_particles(x_positions, y_positions):
+    inside_circle = np.sum(x_positions**2 + y_positions**2 <= radius**2)
+    total_particles = len(x_positions)
+    pi_estimate = (inside_circle / total_particles) * 4  # Area ratio method
+    return pi_estimate
+
+# Estimate pi
+pi_estimate = estimate_pi_from_particles(x_positions, y_positions)
+print(f"Estimated value of pi based on particle positions: {pi_estimate}")
+
+# Optional: Visualize the particles
+def plot_particles(x_positions, y_positions):
+    plt.figure(figsize=(8, 8))
+    plt.scatter(x_positions[x_positions**2 + y_positions**2 <= radius**2], 
+                y_positions[x_positions**2 + y_positions**2 <= radius**2], 
+                color='blue', s=1)  # Points inside the circle
+    plt.scatter(x_positions[x_positions**2 + y_positions**2 > radius**2], 
+                y_positions[x_positions**2 + y_positions**2 > radius**2], 
+                color='red', s=1)   # Points outside the circle
+    plt.xlim(-1.5, 1.5)
+    plt.ylim(-1.5, 1.5)
+    plt.title('Monte Carlo Simulation of Pi')
+    plt.gca().set_aspect('equal', adjustable='box')
+    plt.axhline(0, color='black', lw=0.5)
+    plt.axvline(0, color='black', lw=0.5)
+    plt.grid()
+    plt.show()
+
+# Uncomment the line below to visualize the particles
+# plot_particles(x_positions, y_positions)
+

pi2.py

@@ -0,0 +1,53 @@
+import decimal
+from decimal import Decimal, getcontext
+
+# Set the precision
+getcontext().prec = 110
+
+# Constants
+c = 299792458  # Speed of light in m/s
+h = Decimal('6.62607015e-34')  # Planck constant in J*s
+k_B = Decimal('1.38e-23')  # Boltzmann constant in J/K
+TSR = Decimal(c**2) / k_B  # Temperature to Speed Ratio in K*m/s
+Q = Decimal('2') ** (Decimal('1') / Decimal('12'))  # Fractal structure parameter
+
+def chudnovsky_pi(n_terms):
+    C = Decimal(426880) * Decimal(10005).sqrt()
+    K = Decimal(6)
+    M = Decimal(1)
+    X = Decimal(1)
+    L = Decimal(13591409)
+    S = Decimal(0)  # Initialize S to 0
+    for i in range(1, n_terms + 1):  # Change to n_terms + 1 to avoid i = 0
+        if i == 1:  # Handle the first iteration separately
+            M = Decimal(1)  # Set M to 1 for the first iteration
+        else:
+            divisor = Decimal((i-1)**3)
+            if divisor == Decimal(0):  # Check for zero divisor
+                divisor = Decimal(1)  # Set divisor to 1 to avoid division by zero
+            M = (K**3 - Decimal(16)*K) * M // divisor
+        L += Decimal(545140134)
+        X *= Decimal(-262537412640768000)
+        term = Decimal(M * L) / X
+        # Apply fractal Q to the term
+        term *= Q ** (Decimal(i) / Decimal(n_terms))
+        # Apply TSR and quantum fluctuations conservatively
+        if term < Decimal('1e-15'):
+            TSR_rel = TSR
+            ΔTSR_q = Decimal('0')
+        else:
+            TSR_rel = TSR / Decimal((1 - (term**2 / Decimal(c**2))).sqrt())
+            ΔTSR_q = h * term
+        S += term * TSR_rel + ΔTSR_q
+        K += Decimal(12)
+    pi = C / S
+    return +pi
+
+# Example usage
+pi = chudnovsky_pi(100)
+print(f"π ≈ {pi}")
+
+# Save results to a JSON file
+import json
+with open('pi_simulation_results.json', 'w') as f:
+    json.dump({"pi_approx": str(pi)}, f)

pi3.py

@@ -0,0 +1,148 @@
+import numpy as np
+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  # Convert to SI units (s^-1)
+
+# Initial conditions
+temperature_initial = 1.0  # Planck temperature in K
+particle_density_initial = 5.16e96  # Planck density in kg/m^3
+particle_speed_initial = TSR * temperature_initial  # Initial speed based on TSR
+
+# Simulation time
+t_planck = 5.39e-44  # Planck time in s
+t_simulation = t_planck * 1e5  # 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,
+    "electron": 5.11e-4,
+    "muon": 1.05e-1,
+    "tau": 1.78,
+    "photon": 0,
+}
+
+# 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.00000000001, 0.00000000010, 0.00000000001 )  # 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 and collisions
+def relativistic_energy(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * c**2 / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def relativistic_momentum(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * particle_speed / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def update_speed(current_speed, current_temperature, particle_mass):
+    """Update the speed of a particle based on temperature and mass."""
+    return TSR * current_temperature  # Update speed using TSR
+
+def check_collision(particle_speeds, collision_distance):
+    epsilon = 1e-15  # A small value to avoid invalid subtraction
+    for j in range(len(particle_speeds)):
+        for k in range(j+1, len(particle_speeds)):
+            if np.abs(particle_speeds[j] - particle_speeds[k]) < collision_distance + epsilon:
+                return True, j, k
+    return False, -1, -1
+
+def handle_collision(particle_speeds, particle_masses, idx1, idx2):
+    """Handle a collision between two particles."""
+    p1 = relativistic_momentum(particle_speeds[idx1], particle_masses[idx1])
+    p2 = relativistic_momentum(particle_speeds[idx2], particle_masses[idx2])
+    
+    # Calculate velocities after collision using conservation of momentum
+    total_momentum = p1 + p2
+    total_mass = particle_masses[idx1] + particle_masses[idx2]
+    v1_new = (total_momentum / total_mass) * (particle_masses[idx1] / total_mass)
+    v2_new = (total_momentum / total_mass) * (particle_masses[idx2] / total_mass)
+    
+    particle_speeds[idx1], particle_speeds[idx2] = v1_new, v2_new
+
+#...
+
+# Simulate the Big Bang with Dark Energy, Dark Matter, Tunneling, and Relativistic Effects
+for tunneling_probability in tunneling_probabilities:
+    print(f"Simulating 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
+    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_speeds[j, 0] = particle_speed_initial  # Initialize speed
+        particle_temperatures[j, 0] = temperature_initial  # Initialize temperature
+        
+        for i in range(1, num_steps):
+            # Update temperature based on expansion of the universe
+            particle_temperatures[j, i] = particle_temperatures[j, i-1] * (1 - Hubble_constant_SI * t_planck)
+            
+            # Update speed using TSR
+            particle_speeds[j, i] = update_speed(particle_speeds[j, i-1], particle_temperatures[j, i], particle_masses[j])
+            
+            # Apply tunneling effect
+            if np.random.rand() < tunneling_probability:
+                particle_speeds[j, i] = particle_speeds[j, 0]
+                tunneling_steps[j, i] = True
+            
+	    # Calculate entropy using von Neumann entropy formula
+            if particle_masses[j] == 0:
+    	        entropy = 0
+            else:
+    	        entropy = -particle_masses[j] * np.log1p(particle_masses[j])
+            
+            # Update mass based on entropy
+            particle_masses_evolution[j, i] = particle_masses_evolution[j, i-1] + entropy / c**2
+            
+            # Check for entanglement
+            if particle_speeds[j, i] == c and particle_temperatures[j, i] == 0:
+                print(f"Entanglement detected for particle {quark} at step {i}")
+                
+    # Print calculated masses at the end of the simulation
+    print(f"Calculated masses at the end of the simulation using the von Neumann entropy (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")
+
+    # Save data to JSON file
+    data_filename = os.path.join(data_dir, f"big_bang_simulation_data_{tunneling_probability:.2f}.json")
+    data = {
+        "tunneling_probability": tunneling_probability,
+        "particle_masses_evolution": particle_masses_evolution.tolist(),
+        "particle_speeds": particle_speeds.tolist(),
+        "particle_temperatures": particle_temperatures.tolist(),
+        "tunneling_steps": tunneling_steps.tolist()
+    }
+    with open(data_filename, "w") as f:
+        json.dump(data, f)

requirements.txt

@@ -0,0 +1,9 @@
+streamlit==1.24.1
+pandas>2.0
+numpy<=1.25.1
+plotly
+cupy-cuda12x
+matplotlib
+scipy
+tqdm
+json

sim.py

@@ -0,0 +1,391 @@
+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)
+
+

sim10.py

@@ -0,0 +1,198 @@
+import numpy as np
+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.1056e-52  # 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 * 1e5  # 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,
+    "electron": 5.11e-4,
+    "muon": 1.05e-1,
+    "tau": 1.78,
+    "photon": 0,
+}
+
+# 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, 4.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 and collisions
+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)
+    )
+
+def check_collision(particle_speeds, collision_distance):
+    # Assuming 1D for simplicity. Expand for 3D if needed.
+    for j in range(len(particle_speeds)):
+        for k in range(j+1, len(particle_speeds)):
+            if np.abs(particle_speeds[j] - particle_speeds[k]) < collision_distance:
+                return True, j, k
+    return False, -1, -1
+
+# Simulate the Big Bang with Dark Energy, Dark Matter, Tunneling, and Relativistic Effects
+for tunneling_probability in tunneling_probabilities:
+    print(f"Simulating 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
+    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
+
+        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],
+            )
+
+            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
+                        ]
+
+            # 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
+
+            # Check for collisions and handle them
+            collision, idx1, idx2 = check_collision(particle_speeds[:, i], collision_distance)
+            if collision:
+                # Simplified collision response: reverse speeds
+                particle_speeds[idx1, i], particle_speeds[idx2, i] = -particle_speeds[idx1, i], -particle_speeds[idx2, i]
+
+    # 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"
+        )
+
+    # Save data to JSON file
+    data_filename = os.path.join(
+        data_dir, f"big_bang_simulation_data_{tunneling_probability:.2f}.json"
+    )
+    data = {
+        "tunneling_probability": tunneling_probability,
+        "particle_masses_evolution": particle_masses_evolution.tolist(),
+        "particle_speeds": particle_speeds.tolist(),
+        "particle_temperatures": particle_temperatures.tolist(),
+        "tunneling_steps": tunneling_steps.tolist()
+    }
+    with open(data_filename, "w") as f:
+        json.dump(data, f)
+

sim11.py

@@ -0,0 +1,147 @@
+import numpy as np
+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  # Convert to SI units (s^-1)
+
+# Initial conditions
+temperature_initial = 1.0  # 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 * 1e5  # 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,
+    "electron": 5.11e-4,
+    "muon": 1.05e-1,
+    "tau": 1.78,
+    "photon": 0,
+}
+
+# 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(99.1, 100.0, 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 and collisions
+def relativistic_energy(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * c**2 / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def relativistic_momentum(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * particle_speed / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def update_speed(current_speed, current_temperature, particle_mass):
+    """Update the speed of a particle based on temperature and mass."""
+    rel_momentum = relativistic_momentum(current_speed, particle_mass)
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return c * np.sqrt(1 - (rel_momentum / (rel_momentum + dark_energy_density + epsilon)) ** 2)
+
+def check_collision(particle_speeds, collision_distance):
+    epsilon = 1e-15  # A small value to avoid invalid subtraction
+    for j in range(len(particle_speeds)):
+        for k in range(j+1, len(particle_speeds)):
+            if np.abs(particle_speeds[j] - particle_speeds[k]) < collision_distance + epsilon:
+                return True, j, k
+    return False, -1, -1
+def handle_collision(particle_speeds, particle_masses, idx1, idx2):
+    """Handle a collision between two particles."""
+    p1 = relativistic_momentum(particle_speeds[idx1], particle_masses[idx1])
+    p2 = relativistic_momentum(particle_speeds[idx2], particle_masses[idx2])
+    
+    # Calculate velocities after collision using conservation of momentum
+    total_momentum = p1 + p2
+    total_mass = particle_masses[idx1] + particle_masses[idx2]
+    v1_new = (total_momentum / total_mass) * (particle_masses[idx1] / total_mass)
+    v2_new = (total_momentum / total_mass) * (particle_masses[idx2] / total_mass)
+    
+    particle_speeds[idx1], particle_speeds[idx2] = v1_new, v2_new
+
+# Simulate the Big Bang with Dark Energy, Dark Matter, Tunneling, and Relativistic Effects
+for tunneling_probability in tunneling_probabilities:
+    print(f"Simulating 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
+    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
+        
+        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]
+            )
+            
+            # Apply tunneling effect
+            if np.random.rand() < tunneling_probability:
+                particle_speeds[j, i] = particle_speeds[j, 0]
+                tunneling_steps[j, i] = True
+            
+            particle_temperatures[j, i] = alpha * particle_speeds[j, i] ** 2  # Apply TSR equation
+            
+            # Update mass based on energy conversion
+            energy_diff = relativistic_energy(particle_speeds[j, i], particle_masses[j]) - relativistic_energy(particle_speeds[j, i - 1], particle_masses[j])
+            particle_masses_evolution[j, i] = particle_masses_evolution[j, i - 1] + energy_diff / c**2
+            
+            # Apply expansion of the universe
+            particle_speeds[j, i] *= 1 - Hubble_constant_SI * t_planck
+            particle_temperatures[j, i] *= 1 - Hubble_constant_SI * t_planck
+            
+            # Check for collisions and handle them
+            collision, idx1, idx2 = check_collision(particle_speeds[:, i], collision_distance)
+            if collision:
+                handle_collision(particle_speeds[:, i], particle_masses, idx1, idx2)
+
+    # 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")
+
+    # Save data to JSON file
+    data_filename = os.path.join(data_dir, f"big_bang_simulation_data_{tunneling_probability:.2f}.json")
+    data = {
+        "tunneling_probability": tunneling_probability,
+        "particle_masses_evolution": particle_masses_evolution.tolist(),
+        "particle_speeds": particle_speeds.tolist(),
+        "particle_temperatures": particle_temperatures.tolist(),
+        "tunneling_steps": tunneling_steps.tolist()
+    }
+    with open(data_filename, "w") as f:
+        json.dump(data, f)

sim2.py

@@ -0,0 +1,152 @@
+import numpy as np
+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 * 1e5  # 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,
+    "electron": 5.11e-4,
+    "muon": 1.05e-1,
+    "tau": 1.78,
+    "photon": 0,
+}
+
+# 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.01, 2.5, 0.1)  # Adjust range as needed
+
+# 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 and collisions
+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)
+    )
+
+def check_collision(particle_speeds, collision_distance):
+    # Assuming 1D for simplicity. Expand for 3D if needed.
+    for j in range(len(particle_speeds)):
+        for k in range(j + 1, len(particle_speeds)):
+            if np.abs(particle_speeds[j] - particle_speeds[k]) < collision_distance:
+                return True, j, k
+    return False, -1, -1
+
+def handle_collision(particle_speeds, idx1, idx2):
+    # Exchange momentum for a simplified collision response
+    p1 = relativistic_momentum(particle_speeds[idx1], particle_masses[idx1])
+    p2 = relativistic_momentum(particle_speeds[idx2], particle_masses[idx2])
+    
+    # Simplified exchange
+    particle_speeds[idx1], particle_speeds[idx2] = p2 / particle_masses
+[idx1], p1 / particle_masses[idx2]
+
+# Simulate the Big Bang with Dark Energy, Dark Matter, Tunneling, and Relativistic Effects
+for tunneling_probability in tunneling_probabilities:
+    print(f"Simulating 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
+    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()):
+        # Initialize particle speeds and temperatures
+        particle_speeds[j, 0] = particle_speed_initial
+        particle_temperatures[j, 0] = temperature_initial
+        particle_masses_evolution[j, 0] = mass * GeV_to_J  # Convert to Joules
+
+    # Time evolution loop
+    for step in range(1, num_steps):
+        for j in range(len(quark_masses)):
+            # Update temperature based on some model (placeholder)
+            particle_temperatures[j, step] = particle_temperatures[j, step - 1] * 0.99  # Cooling down
+
+            # Update speed based on temperature and mass
+            particle_speeds[j, step] = update_speed(
+                particle_speeds[j, step - 1], 
+                particle_temperatures[j, step], 
+                particle_masses[j]
+            )
+
+            # Check for collisions
+            collision_detected, idx1, idx2 = check_collision(particle_speeds[:, step], collision_distance)
+            if collision_detected:
+                handle_collision(particle_speeds[:, step], idx1, idx2)
+
+            # Tunneling effect (placeholder for actual physics)
+            if np.random.rand() < tunneling_probability:
+                tunneling_steps[j, step] = True
+                # Modify mass or speed based on tunneling (placeholder)
+                particle_masses[j] *= 1.1  # Increase mass as an example
+
+        # Store mass evolution
+        particle_masses_evolution[:, step] = particle_masses
+
+    # Save the simulation data for this tunneling probability
+    simulation_data = {
+        "particle_speeds": particle_speeds.tolist(),  # Convert to list for JSON serialization
+        "particle_temperatures": particle_temperatures.tolist(),  # Convert to list for JSON serialization
+        "particle_masses_evolution": particle_masses_evolution.tolist(),  # Convert to list for JSON serialization
+        "tunneling_steps": tunneling_steps.tolist(),  # Convert to list for JSON serialization
+    }
+
+    with open(os.path.join(data_dir, f"simulation_tunneling_{tunneling_probability:.2f}.json"), "w") as f:
+        json.dump(simulation_data, f)
+
+print("Simulation completed and data saved.")
+

sim3.py

@@ -0,0 +1,132 @@
+import numpy as np
+import json
+import os
+
+# Constants
+c = 299792458  # Speed of light in m/s
+E_mc2 = c**2  # Mass-energy equivalence in J/kg
+dark_energy_density = 5.96e-27  # Density of dark energy in kg/m^3
+collision_distance = 1e-10  # Distance for collision detection
+
+# Initial conditions
+temperature_initial = 1.42e32  # Planck temperature in K
+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 * 1e5  # Shorter timescale for simulation
+
+# Quark masses (in GeV)
+quark_masses = {
+    "up": 2.3e-3,
+    "down": 4.8e-3,
+    "charm": 1.28,
+    "strange": 0.095,
+    "top": 173.0,
+    "bottom": 4.18,
+    "electron": 5.11e-4,
+    "muon": 1.05e-1,
+    "tau": 1.78,
+    "photon": 0,
+}
+
+# Conversion factor from GeV to J
+GeV_to_J = 1.60217662e-10
+
+# Simulation setup
+num_steps = int(t_simulation / t_planck)
+
+# 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 and collisions
+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):
+    # Placeholder for speed update logic
+    return current_speed  # This should be replaced with actual logic
+
+def check_collision(particle_speeds, collision_distance):
+    for j in range(len(particle_speeds)):
+        for k in range(j + 1, len(particle_speeds)):
+            if np.abs(particle_speeds[j] - particle_speeds[k]) < collision_distance:
+                return True, j, k
+    return False, -1, -1
+
+def handle_collision(particle_speeds, idx1, idx2):
+    # Exchange momentum for a simplified collision response
+    p1 = relativistic_momentum(particle_speeds[idx1], particle_masses[idx1])
+    p2 = relativistic_momentum(particle_speeds[idx2], particle_masses[idx2])
+    
+    # Simplified exchange of speeds based on momentum
+    particle_speeds[idx1] = p2 / particle_masses[idx1]  # Update speed of particle 1
+    particle_speeds[idx2] = p1 / particle_masses[idx2]  # Update speed of particle 2
+
+# Simulate the Big Bang with Dark Energy, Dark Matter, Tunneling, and Relativistic Effects
+for tunneling_probability in np.arange(0.01, 2.5, 0.1):
+    print(f"Simulating 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
+    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
+    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()):
+        # Initialize particle speeds and temperatures
+        particle_speeds[j, 0] = particle_speed_initial
+        particle_temperatures[j, 0] = temperature_initial
+        particle_masses_evolution[j, 0] = mass * GeV_to_J  # Convert to Joules
+
+    # Time evolution loop
+    for step in range(1, num_steps):
+        for j in range(len(quark_masses)):
+            # Update temperature based on some model (placeholder)
+            particle_temperatures[j, step] = particle_temperatures[j, step - 1] * 0.99  # Cooling down
+
+            # Update speed based on temperature and mass
+            particle_speeds[j, step] = update_speed(
+                particle_speeds[j, step - 1], 
+                particle_temperatures[j, step], 
+                particle_masses[j]
+            )
+
+            # Check for collisions
+            collision_detected, idx1, idx2 = check_collision(particle_speeds[:, step], collision_distance)
+            if collision_detected:
+                handle_collision(particle_speeds[:, step], idx1, idx2)
+
+            # Tunneling effect (placeholder for actual physics)
+            if np.random.rand() < tunneling_probability:
+                tunneling_steps[j, step] = True
+                # Modify mass or speed based on tunneling (placeholder)
+                particle_masses[j] *= 1.1  # Increase mass as an example
+
+        # Store mass evolution
+        particle_masses_evolution[:, step] = particle_masses
+
+    # Save the simulation data for this tunneling probability
+    simulation_data = {
+        "particle_speeds": particle_speeds.tolist(),  # Convert to list for JSON serialization
+        "particle_temperatures": particle_temperatures.tolist(),  # Convert to list for JSON serialization
+        "particle_masses_evolution": particle_masses_evolution.tolist(),  # Convert to list for JSON serialization
+        "tunneling_steps": tunneling_steps.tolist(),  # Convert to list for JSON serialization
+    }
+
+    with open(os.path.join(data_dir, f"simulation_tunneling_{tunneling_probability:.2f}.json"), "w") as f:
+        json.dump(simulation_data, f)
+
+print("Simulation completed and data saved.")
+

sim8.py

@@ -0,0 +1,181 @@
+import numpy as np
+import numba
+from numba import cuda
+import dask
+from dask import delayed
+from dask.diagnostics import ProgressBar
+import time
+from scipy.stats import norm
+
+# 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,
+}
+
+# **ASK FOR NUMBER OF PARTICLES**
+while True:
+    try:
+        num_particles = int(input("Enter the number of particles (integer): "))
+        if num_particles <= 0:
+            print("Please enter a positive integer.")
+        else:
+            break
+    except ValueError:
+        print("Invalid input. Please enter an integer.")
+
+# **ASK FOR TUNNELING PROBABILITY**
+while True:
+    try:
+        tunneling_probability = float(input("Enter the tunneling probability (float, 0-1): "))
+        if 0 <= tunneling_probability <= 1:
+            break
+        else:
+            print("Please enter a value between 0 and 1.")
+    except ValueError:
+        print("Invalid input. Please enter a float.")
+
+# Generate additional particles based on user input
+additional_particles = {
+    f"new_quark_{i}": np.random.uniform(1e-3, 1e-1) for i in range(num_particles - len(quark_masses))
+}
+
+all_particles = {**quark_masses, **additional_particles}
+
+# Conversion factor from GeV to J
+GeV_to_J = 1.60217662e-10
+
+# Simulation setup
+num_steps = int(t_simulation / t_planck)
+
+# CUDA kernel for simulation step
+@cuda.jit
+def simulation_step(particle_speeds, particle_temperatures, particle_masses, step, tunneling_probability):
+    tx = cuda.threadIdx.x
+    bx = cuda.blockIdx.x
+    bw = cuda.blockDim.x
+    i = tx + bx * bw
+
+    if i < num_particles:
+        # Update speed
+        particle_speeds[i] = update_speed(
+            particle_speeds[i], particle_temperatures[i], particle_masses[i]
+        )
+
+        # Apply tunneling probability
+        if np.random.rand() < tunneling_probability:
+            particle_speeds[i] = particle_speed_initial
+
+        # Update temperature
+        particle_temperatures[i] = alpha * particle_speeds[i] ** 2
+
+        # Simple collision detection (for demonstration; enhance as needed)
+        for j in range(num_particles):
+            if i != j:
+                # Collision logic here (omitted for brevity)
+                pass  # Placeholder for collision logic
+
+# CPU function for updating speed (example; optimize as necessary)
+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)
+    )
+
+# CPU function for relativistic momentum (example; optimize as necessary)
+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))
+    )
+
+# Generate additional particles based on user input
+additional_particles = {
+    f"new_quark_{i}": np.random.uniform(1e-3, 1e-1) for i in range(num_particles - len(quark_masses))
+}
+
+# Ensure that the number of particles is at least the number of quark masses
+if num_particles < len(quark_masses):
+    print(f"Warning: Reducing the number of particles to {len(quark_masses)} to match quark masses.")
+    num_particles = len(quark_masses)
+
+all_particles = {**quark_masses, **additional_particles}
+
+# Initialize particle properties
+initial_speeds = np.full(num_particles, particle_speed_initial, dtype=np.float64)
+initial_temperatures = np.full(num_particles, temperature_initial, dtype=np.float64)
+
+# Create an array of masses based on the number of particles
+initial_masses = np.zeros(num_particles, dtype=np.float64)
+
+# Fill initial_masses with quark masses and additional particles
+for i, (key, mass) in enumerate(all_particles.items()):
+    if i < num_particles:
+        initial_masses[i] = mass
+
+# Main simulation loop
+def main_simulation(tunneling_probability):
+    # Memory allocation for simulation arrays
+    d_particle_speeds = cuda.device_array(num_particles, dtype=np.float64)
+    d_particle_temperatures = cuda.device_array(num_particles, dtype=np.float64)
+    d_particle_masses = cuda.device_array(num_particles, dtype=np.float64)
+
+    # Copy initial values to device
+    d_particle_speeds.copy_to_device(initial_speeds)
+    d_particle_temperatures.copy_to_device(initial_temperatures)
+    d_particle_masses.copy_to_device(initial_masses)
+
+    # Simulation loop
+    for step in range(num_steps):
+        simulation_step[1, num_particles](d_particle_speeds, d_particle_temperatures, d_particle_masses, step, tunneling_probability)
+
+    # Copy results back to host
+    h_particle_speeds = d_particle_speeds.copy_to_host()
+    h_particle_temperatures = d_particle_temperatures.copy_to_host()
+    h_particle_masses = d_particle_masses.copy_to_host()
+
+    return h_particle_speeds, h_particle_temperatures, h_particle_masses
+
+if __name__ == "__main__":
+    start_time = time.time()
+    with ProgressBar():
+        task = delayed(main_simulation)(tunneling_probability)
+        result = task.compute()
+    end_time = time.time()
+    print(f"Simulation completed in {end_time - start_time} seconds")
+
+    # Process and visualize results as needed
+    particle_speeds, particle_temperatures, particle_masses = result
+    print("Final Particle Speeds:", particle_speeds)
+    print("Final Particle Temperatures:", particle_temperatures)
+    print("Final Particle Masses:", particle_masses)

sim9.py

@@ -0,0 +1,181 @@
+import numpy as np
+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 * 1e5  # 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,
+    "electron": 5.11e-4,
+    "muon": 1.05e-1,
+    "tau": 1.78,
+    "photon": 0,
+}
+
+# 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
+for tunneling_probability in tunneling_probabilities:
+    print(f"Simulating 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
+    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
+
+        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],
+            )
+
+            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
+                        ]
+
+            # 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
+
+    # 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"
+        )
+
+    # 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_masses_evolution": particle_masses_evolution.tolist(),
+    }
+    with open(data_filename, "w") as f:
+        json.dump(data, f)

simA.py

@@ -0,0 +1,146 @@
+import streamlit as st
+
+x = st.slider('Select a value')
+st.write(x, 'squared is', x * x)
+
+import numpy as np
+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  # Convert to SI units (s^-1)
+
+# Initial conditions
+temperature_initial = 1.0  # Planck temperature in K
+particle_density_initial = 5.16e96  # Planck density in kg/m^3
+particle_speed_initial = TSR * temperature_initial  # Initial speed based on TSR
+
+# Simulation time
+t_planck = 5.39e-44  # Planck time in s
+t_simulation = t_planck * 1e5  # 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,
+    "electron": 5.11e-4,
+    "muon": 1.05e-1,
+    "tau": 1.78,
+    "photon": 0,
+}
+
+# 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.000001, 150, 10)
+# 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 and collisions
+def relativistic_energy(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * c**2 / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def relativistic_momentum(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * particle_speed / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def update_speed(current_speed, current_temperature, particle_mass):
+    """Update the speed of a particle based on temperature and mass."""
+    return TSR * current_temperature  # Update speed using TSR
+
+def check_collision(particle_speeds, collision_distance):
+    epsilon = 1e-15  # A small value to avoid invalid subtraction
+    for j in range(len(particle_speeds)):
+        for k in range(j+1, len(particle_speeds)):
+            if np.abs(particle_speeds[j] - particle_speeds[k]) < collision_distance + epsilon:
+                return True, j, k
+    return False, -1, -1
+
+def handle_collision(particle_speeds, particle_masses, idx1, idx2):
+    """Handle a collision between two particles."""
+    p1 = relativistic_momentum(particle_speeds[idx1], particle_masses[idx1])
+    p2 = relativistic_momentum(particle_speeds[idx2], particle_masses[idx2])
+    
+    # Calculate velocities after collision using conservation of momentum
+    total_momentum = p1 + p2
+    total_mass = particle_masses[idx1] + particle_masses[idx2]
+    v1_new = (total_momentum / total_mass) * (particle_masses[idx1] / total_mass)
+    v2_new = (total_momentum / total_mass) * (particle_masses[idx2] / total_mass)
+    
+    particle_speeds[idx1], particle_speeds[idx2] = v1_new, v2_new
+
+# Simulate the Big Bang with Dark Energy, Dark Matter, Tunneling, and Relativistic Effects
+for tunneling_probability in tunneling_probabilities:
+    print(f"Simulating 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
+    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_speeds[j, 0] = particle_speed_initial  # Initialize speed
+        particle_temperatures[j, 0] = temperature_initial  # Initialize temperature
+        
+        for i in range(1, num_steps):
+            # Update temperature based on expansion of the universe
+            particle_temperatures[j, i] = particle_temperatures[j, i-1] * (1 - Hubble_constant_SI * t_planck)
+            
+            # Update speed using TSR
+            particle_speeds[j, i] = update_speed(particle_speeds[j, i-1], particle_temperatures[j, i], particle_masses[j])
+            
+            # Apply tunneling effect
+            if np.random.rand() < tunneling_probability:
+                particle_speeds[j, i] = particle_speeds[j, 0]
+                tunneling_steps[j, i] = True
+            
+            # Update mass based on energy conversion
+            energy_diff = relativistic_energy(particle_speeds[j, i], particle_masses[j]) - relativistic_energy(particle_speeds[j, i - 1], particle_masses[j])
+            particle_masses_evolution[j, i] = particle_masses_evolution[j, i - 1] + energy_diff / c**2
+            
+            # Check for collisions and handle them
+            collision, idx1, idx2 = check_collision(particle_speeds[:, i], collision_distance)
+            if collision:
+                handle_collision(particle_speeds[:, i], particle_masses, idx1, idx2)
+
+    # Print calculated masses at the end of the simulation
+    print(f"Calculated masses at the end of the simulation at the colision (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")
+
+    # Save data to JSON file
+    data_filename = os.path.join(data_dir, f"big_bang_simulation_data_{tunneling_probability:.2f}.json")
+    data = {
+        "tunneling_probability": tunneling_probability,
+        "particle_masses_evolution": particle_masses_evolution.tolist(),
+        "particle_speeds": particle_speeds.tolist(),
+        "particle_temperatures": particle_temperatures.tolist(),
+        "tunneling_steps": tunneling_steps.tolist()
+    }
+    with open(data_filename, "w") as f:
+        json.dump(data, f)

simAZ.py

@@ -0,0 +1,171 @@
+import numpy as np
+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  # Convert to SI units (s^-1)
+
+# Initial conditions
+temperature_initial = 1.0  # Planck temperature in K
+particle_density_initial = 5.16e96  # Planck density in kg/m^3
+particle_speed_initial = TSR * temperature_initial  # Initial speed based on TSR
+
+# Simulation time
+t_planck = 5.39e-44  # Planck time in s
+t_simulation = t_planck * 1e5  # Shorter timescale for simulation
+
+# Updated particle masses (in GeV)
+particle_masses = {
+    "up": 2.3e-3,
+    "down": 4.8e-3,
+    "charm": 1.28,
+    "strange": 0.095,
+    "top": 173.0,
+    "bottom": 4.18,
+    "electron": 5.11e-4,
+    "muon": 1.05e-1,
+    "tau": 1.78,
+    "photon": 0,
+    "electron_neutrino": 0,  # Neutrinos have very small masses
+    "muon_neutrino": 0,
+    "tau_neutrino": 0,
+    "W_boson": 80.379,
+    "Z_boson": 91.1876,
+    "Higgs_boson": 125.1,
+    "gluon": 0,  # Massless
+    "proton": 0.938,
+    "neutron": 0.939,
+    "pion_plus": 0.140,
+    "pion_zero": 0.135,
+    "kaon_plus": 0.494,
+    "kaon_zero": 0.498
+}
+
+# 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.5, 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 and collisions
+def relativistic_energy(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * c**2 / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def relativistic_momentum(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * particle_speed / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def update_speed(current_speed, current_temperature, particle_mass):
+    """Update the speed of a particle based on temperature and mass."""
+    return TSR * current_temperature  # Update speed using TSR
+
+def check_collision(particle_speeds, collision_distance):
+    epsilon = 1e-15  # A small value to avoid invalid subtraction
+    for j in range(len(particle_speeds)):
+        for k in range(j+1, len(particle_speeds)):
+            if np.abs(particle_speeds[j] - particle_speeds[k]) < collision_distance + epsilon:
+                return True, j, k
+    return False, -1, -1
+
+def handle_collision(particle_speeds, particle_masses, idx1, idx2):
+    """Handle a collision between two particles."""
+    if particle_masses[idx1] == 0 or particle_masses[idx2] == 0:
+        # Skip handling collisions involving massless particles
+        return
+    
+    p1 = relativistic_momentum(particle_speeds[idx1], particle_masses[idx1])
+    p2 = relativistic_momentum(particle_speeds[idx2], particle_masses[idx2])
+    
+    # Calculate velocities after collision using conservation of momentum
+    total_momentum = p1 + p2
+    total_mass = particle_masses[idx1] + particle_masses[idx2]
+    v1_new = (total_momentum / total_mass) * (particle_masses[idx1] / total_mass)
+    v2_new = (total_momentum / total_mass) * (particle_masses[idx2] / total_mass)
+    
+    particle_speeds[idx1], particle_speeds[idx2] = v1_new, v2_new
+
+# Simulate the Big Bang with Dark Energy, Dark Matter, Tunneling, and Relativistic Effects
+for tunneling_probability in tunneling_probabilities:
+    print(f"Simulating for tunneling probability: {tunneling_probability}")
+    
+    # Initialize arrays for simulation
+    particle_speeds = np.zeros((len(particle_masses), num_steps))  # 2D array for speeds
+    particle_temperatures = np.zeros((len(particle_masses), num_steps))  # 2D array for temperatures
+    particle_masses_evolution = np.zeros((len(particle_masses), num_steps))  # 2D array for mass evolution
+    tunneling_steps = np.zeros((len(particle_masses), num_steps), dtype=bool)  # 2D array for tunneling steps
+    particle_momentum = np.zeros((len(particle_masses), num_steps))  # 2D array for momentum
+    total_energy = np.zeros(num_steps)  # 1D array for total energy of the system
+    
+    # Create an array of masses for each particle
+    particle_masses_array = np.array([mass * GeV_to_J for mass in particle_masses.values()])
+    
+    for j, (particle, mass) in enumerate(particle_masses.items()):
+        particle_masses_evolution[j, 0] = particle_masses_array[j]  # Initialize mass
+        particle_speeds[j, 0] = particle_speed_initial  # Initialize speed
+        particle_temperatures[j, 0] = temperature_initial  # Initialize temperature
+        particle_momentum[j, 0] = relativistic_momentum(particle_speeds[j, 0], particle_masses_array[j])  # Initialize momentum
+        
+        for i in range(1, num_steps):
+            # Update temperature based on expansion of the universe
+            particle_temperatures[j, i] = particle_temperatures[j, i-1] * (1 - Hubble_constant_SI * t_planck)
+            
+            # Update speed using TSR
+            particle_speeds[j, i] = update_speed(particle_speeds[j, i-1], particle_temperatures[j, i], particle_masses_array[j])
+            
+            # Apply tunneling effect
+            if np.random.rand() < tunneling_probability:
+                particle_speeds[j, i] = particle_speeds[j, 0]
+                tunneling_steps[j, i] = True
+            
+            # Update mass based on energy conversion
+            energy_diff = relativistic_energy(particle_speeds[j, i], particle_masses_array[j]) - relativistic_energy(particle_speeds[j, i - 1], particle_masses_array[j])
+            particle_masses_evolution[j, i] = particle_masses_evolution[j, i - 1] + energy_diff / c**2
+            
+            # Check for collisions and handle them
+            collision, idx1, idx2 = check_collision(particle_speeds[:, i], collision_distance)
+            if collision:
+                handle_collision(particle_speeds[:, i], particle_masses_array, idx1, idx2)
+            
+            # Update momentum
+            particle_momentum[j, i] = relativistic_momentum(particle_speeds[j, i], particle_masses_array[j])
+            
+            # Update total energy
+            total_energy[i] = np.sum([relativistic_energy(particle_speeds[k, i], particle_masses_array[k]) for k in range(len(particle_masses))])
+
+    # 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, particle in enumerate(particle_masses.keys()):
+        print(f"{particle}: {particle_masses_evolution[j, -1] / GeV_to_J:.4e} GeV")
+
+    # Save data to JSON file
+    data_filename = os.path.join(data_dir, f"big_bang_simulation_data_{tunneling_probability:.2f}.json")
+    data = {
+        "tunneling_probability": tunneling_probability,
+        "particle_masses_evolution": particle_masses_evolution.tolist(),
+        "particle_speeds": particle_speeds.tolist(),
+        "particle_temperatures": particle_temperatures.tolist(),
+        "tunneling_steps": tunneling_steps.tolist(),
+        "particle_momentum": particle_momentum.tolist(),
+        "total_energy": total_energy.tolist()
+    }
+    with open(data_filename, "w") as f:
+        json.dump(data, f)
+

simB.py

@@ -0,0 +1,132 @@
+import numpy as np
+import json
+import os
+
+# Constants
+c = 299792458  # Speed of light in m/s
+E_mc2 = c**2  # Mass-energy equivalence in J/kg
+dark_energy_density = 5.96e-27  # Density of dark energy in kg/m^3
+collision_distance = 1e-10  # Distance for collision detection
+
+# Initial conditions
+temperature_initial = 1.42e32  # Planck temperature in K
+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 * 1e5  # Shorter timescale for simulation
+
+# Quark masses (in GeV)
+quark_masses = {
+    "up": 2.3e-3,
+    "down": 4.8e-3,
+    "charm": 1.28,
+    "strange": 0.095,
+    "top": 173.0,
+    "bottom": 4.18,
+    "electron": 5.11e-4,
+    "muon": 1.05e-1,
+    "tau": 1.78,
+    "photon": 0,
+}
+
+# Conversion factor from GeV to J
+GeV_to_J = 1.60217662e-10
+
+# Simulation setup
+num_steps = int(t_simulation / t_planck)
+
+# 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 and collisions
+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):
+    # Placeholder for speed update logic
+    return current_speed  # This should be replaced with actual logic
+
+def check_collision(particle_speeds, collision_distance):
+    for j in range(len(particle_speeds)):
+        for k in range(j + 1, len(particle_speeds)):
+            if np.abs(particle_speeds[j] - particle_speeds[k]) < collision_distance:
+                return True, j, k
+    return False, -1, -1
+
+def handle_collision(particle_speeds, idx1, idx2):
+    # Exchange momentum for a simplified collision response
+    p1 = relativistic_momentum(particle_speeds[idx1], particle_masses[idx1])
+    p2 = relativistic_momentum(particle_speeds[idx2], particle_masses[idx2])
+    
+    # Simplified exchange of speeds based on momentum
+    particle_speeds[idx1] = p2 / particle_masses[idx1]  # Update speed of particle 1
+    particle_speeds[idx2] = p1 / particle_masses[idx2]  # Update speed of particle 2
+
+# Simulate the Big Bang with Dark Energy, Dark Matter, Tunneling, and Relativistic Effects
+for tunneling_probability in np.arange(0.01, 2.5, 0.1):
+    print(f"Simulating 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
+    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
+    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()):
+        # Initialize particle speeds and temperatures
+        particle_speeds[j, 0] = particle_speed_initial
+        particle_temperatures[j, 0] = temperature_initial
+        particle_masses_evolution[j, 0] = mass * GeV_to_J  # Convert to Joules
+
+    # Time evolution loop
+    for step in range(1, num_steps):
+        for j in range(len(quark_masses)):
+            # Update temperature based on some model (placeholder)
+            particle_temperatures[j, step] = particle_temperatures[j, step - 1] * 0.99  # Cooling down
+
+            # Update speed based on temperature and mass
+            particle_speeds[j, step] = update_speed(
+                particle_speeds[j, step - 1], 
+                particle_temperatures[j, step], 
+                particle_masses[j]
+            )
+
+            # Check for collisions
+            collision_detected, idx1, idx2 = check_collision(particle_speeds[:, step], collision_distance)
+            if collision_detected:
+                handle_collision(particle_speeds[:, step], idx1, idx2)
+
+            # Tunneling effect (placeholder for actual physics)
+            if np.random.rand() < tunneling_probability:
+                tunneling_steps[j, step] = True
+                # Modify mass or speed based on tunneling (placeholder)
+                particle_masses[j] *= 1.1  # Increase mass as an example
+
+        # Store mass evolution
+        particle_masses_evolution[:, step] = particle_masses
+
+    # Save the simulation data for this tunneling probability
+    simulation_data = {
+        "particle_speeds": particle_speeds.tolist(),  # Convert to list for JSON serialization
+        "particle_temperatures": particle_temperatures.tolist(),  # Convert to list for JSON serialization
+        "particle_masses_evolution": particle_masses_evolution.tolist(),  # Convert to list for JSON serialization
+        "tunneling_steps": tunneling_steps.tolist(),  # Convert to list for JSON serialization
+    }
+
+    with open(os.path.join(data_dir, f"simulation_tunneling_{tunneling_probability:.2f}.json"), "w") as f:
+        json.dump(simulation_data, f)
+
+print("Simulation completed and data saved.")
+

simC.py

@@ -0,0 +1,156 @@
+import numpy as np
+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  # Convert to SI units (s^-1)
+
+# Initial conditions
+temperature_initial = 1.0  # Planck temperature in K
+particle_density_initial = 5.16e96  # Planck density in kg/m^3
+particle_speed_initial = TSR * temperature_initial  # Initial speed based on TSR
+
+# Simulation time
+t_planck = 5.39e-44  # Planck time in s
+t_simulation = t_planck * 1e5  # Shorter timescale for simulation
+
+# Particle masses (in GeV)
+particle_masses = {
+    "up": 2.3e-3,
+    "down": 4.8e-3,
+    "charm": 1.28,
+    "strange": 0.095,
+    "top": 173.0,
+    "bottom": 4.18,
+    "electron": 5.11e-4,
+    "muon": 1.05e-1,
+    "tau": 1.78,
+    "photon": 0,
+    "electron_neutrino": 0,  # Neutrinos have very small masses
+    "muon_neutrino": 0,
+    "tau_neutrino": 0,
+    "W_boson": 80.379,
+    "Z_boson": 91.1876,
+    "Higgs_boson": 125.1,
+    "gluon": 0,  # Massless
+    "proton": 0.938,
+    "neutron": 0.939,
+    "pion_plus": 0.140,
+    "pion_zero": 0.135,
+    "kaon_plus": 0.494,
+    "kaon_zero": 0.498
+}
+
+# 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.001, 1.5, 0.001)  # 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 and collisions
+def relativistic_energy(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * c**2 / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def relativistic_momentum(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * particle_speed / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def update_speed(current_speed, current_temperature, particle_mass):
+    """Update the speed of a particle based on temperature and mass."""
+    return TSR * current_temperature  # Update speed using TSR
+
+def check_collision(particle_speeds, collision_distance, current_step):
+    for j in range(len(particle_speeds)):
+        for k in range(j+1, len(particle_speeds)):
+            if np.abs(particle_speeds[j][current_step] - particle_speeds[k][current_step]) < collision_distance:
+                return True, j, k
+    return False, -1, -1
+
+def handle_collision(particle_speeds, particle_masses, idx1, idx2, current_step):
+    """Handle a collision between two particles."""
+    p1 = relativistic_momentum(particle_speeds[idx1][current_step], particle_masses[idx1])
+    p2 = relativistic_momentum(particle_speeds[idx2][current_step], particle_masses[idx2])
+    
+    # Calculate velocities after collision using conservation of momentum
+    total_momentum = p1 + p2
+    total_mass = particle_masses[idx1] + particle_masses[idx2]
+    v1_new = (total_momentum / total_mass) * (particle_masses[idx1] / total_mass)
+    v2_new = (total_momentum / total_mass) * (particle_masses[idx2] / total_mass)
+    
+    particle_speeds[idx1][current_step] = v1_new
+    particle_speeds[idx2][current_step] = v2_new
+
+# Simulate the Big Bang with Dark Energy, Dark Matter, Tunneling, and Relativistic Effects
+for tunneling_probability in tunneling_probabilities:
+    print(f"Simulating for tunneling probability: {tunneling_probability}")
+    
+    # Initialize arrays for simulation
+    num_particles = len(particle_masses)
+    particle_speeds = [[particle_speed_initial] * num_steps for _ in range(num_particles)]
+    particle_temperatures = [[temperature_initial] * num_steps for _ in range(num_particles)]
+    particle_masses_evolution = [[mass * GeV_to_J] * num_steps for mass in particle_masses.values()]
+    tunneling_steps = [[False] * num_steps for _ in range(num_particles)]
+    particle_masses_array = np.array([mass * GeV_to_J for mass in particle_masses.values()])
+    
+    for current_step in range(1, num_steps):
+        for j in range(num_particles):
+            # Update temperature based on expansion of the universe
+            particle_temperatures[j][current_step] = particle_temperatures[j][current_step-1] * (1 - Hubble_constant_SI * t_planck)
+            
+            # Update speed using TSR
+            particle_speeds[j][current_step] = update_speed(particle_speeds[j][current_step-1], particle_temperatures[j][current_step], particle_masses_array[j])
+            
+            # Apply tunneling effect
+            if np.random.rand() < tunneling_probability:
+                particle_speeds[j][current_step] = particle_speeds[j][0]
+                tunneling_steps[j][current_step] = True
+        
+        # Check for collisions
+        collision_detected, idx1, idx2 = check_collision(particle_speeds, collision_distance, current_step)
+        if collision_detected:
+            handle_collision(particle_speeds, particle_masses_array, idx1, idx2, current_step)
+        
+        # Calculate entropy using von Neumann entropy formula
+        for j in range(num_particles):
+            if particle_masses_array[j] == 0:
+                entropy = 0
+            else:
+                entropy = -particle_masses_array[j] * np.log1p(particle_masses_array[j])
+            
+            # Update mass based on entropy
+            particle_masses_evolution[j][current_step] = particle_masses_evolution[j][current_step-1] + entropy / c**2
+    
+    # Print calculated masses at the end of the simulation
+    print(f"Calculated masses at the end of the simulation using the von Neumann entropy (Tunneling Probability: {tunneling_probability}):")
+    for j, particle in enumerate(particle_masses.keys()):
+        print(f"{particle}: {particle_masses_evolution[j][-1] / GeV_to_J:.4e} GeV")
+
+    # Save data to JSON file
+data_filename = os.path.join(data_dir, f"big_bang_simulation_data_{tunneling_probability:.2f}.json")
+data = {
+    "tunneling_probability": tunneling_probability,
+    "particle_masses_evolution": particle_masses_evolution,  # No need for tolist()
+    "particle_speeds": particle_speeds,
+    "particle_temperatures": particle_temperatures,
+    "tunneling_steps": tunneling_steps
+}
+with open(data_filename, "w") as f:
+    json.dump(data, f)

simD.py

@@ -0,0 +1,163 @@
+import numpy as np
+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  # Convert to SI units (s^-1)
+
+# Initial conditions
+temperature_initial = 1.0  # Planck temperature in K
+particle_density_initial = 5.16e96  # Planck density in kg/m^3
+particle_speed_initial = TSR * temperature_initial  # Initial speed based on TSR
+
+# Simulation time
+t_planck = 5.39e-44  # Planck time in s
+t_simulation = t_planck * 1e5  # Shorter timescale for simulation
+
+# Updated particle masses (in GeV)
+particle_masses = {
+    "up": 2.3e-3,
+    "down": 4.8e-3,
+    "charm": 1.28,
+    "strange": 0.095,
+    "top": 173.0,
+    "bottom": 4.18,
+    "electron": 5.11e-4,
+    "muon": 1.05e-1,
+    "tau": 1.78,
+    "photon": 0,
+    "electron_neutrino": 0,  # Neutrinos have very small masses
+    "muon_neutrino": 0,
+    "tau_neutrino": 0,
+    "W_boson": 80.379,
+    "Z_boson": 91.1876,
+    "Higgs_boson": 125.1,
+    "gluon": 0,  # Massless
+    "proton": 0.938,
+    "neutron": 0.939,
+    "pion_plus": 0.140,
+    "pion_zero": 0.135,
+    "kaon_plus": 0.494,
+    "kaon_zero": 0.498
+}
+
+# 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.5, 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 and collisions
+def relativistic_energy(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * c**2 / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def relativistic_momentum(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * particle_speed / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def update_speed(current_speed, current_temperature, particle_mass):
+    """Update the speed of a particle based on temperature and mass."""
+    return TSR * current_temperature  # Update speed using TSR
+
+def check_collision(particle_speeds, collision_distance):
+    epsilon = 1e-15  # A small value to avoid invalid subtraction
+    for j in range(len(particle_speeds)):
+        for k in range(j+1, len(particle_speeds)):
+            if np.abs(particle_speeds[j] - particle_speeds[k]) < collision_distance + epsilon:
+                return True, j, k
+    return False, -1, -1
+
+def handle_collision(particle_speeds, particle_masses, idx1, idx2):
+    """Handle a collision between two particles."""
+    p1 = relativistic_momentum(particle_speeds[idx1], particle_masses[idx1])
+    p2 = relativistic_momentum(particle_speeds[idx2], particle_masses[idx2])
+    
+    # Calculate velocities after collision using conservation of momentum
+    total_momentum = p1 + p2
+    total_mass = particle_masses[idx1] + particle_masses[idx2]
+    
+    # Check for division by zero
+    if total_mass == 0:
+        # If total_mass is zero, set the velocities to zero
+        particle_speeds[idx1] = 0
+        particle_speeds[idx2] = 0
+        return
+    
+    v1_new = (total_momentum / total_mass) * (particle_masses[idx1] / total_mass)
+    v2_new = (total_momentum / total_mass) * (particle_masses[idx2] / total_mass)
+    
+    particle_speeds[idx1], particle_speeds[idx2] = v1_new, v2_new
+
+# Simulate the Big Bang with Dark Energy, Dark Matter, Tunneling, and Relativistic Effects
+for tunneling_probability in tunneling_probabilities:
+    print(f"Simulating for tunneling probability: {tunneling_probability}")
+    
+    # Initialize arrays for simulation
+    particle_speeds = np.zeros((len(particle_masses), num_steps))  # 2D array for speeds
+    particle_temperatures = np.zeros((len(particle_masses), num_steps))  # 2D array for temperatures
+    particle_masses_evolution = np.zeros((len(particle_masses), num_steps))  # 2D array for mass evolution
+    tunneling_steps = np.zeros((len(particle_masses), num_steps), dtype=bool)  # 2D array for tunneling steps
+    
+    # Create an array of masses for each particle
+    particle_masses_array = np.array([mass * GeV_to_J for mass in particle_masses.values()])
+    
+    for j, (particle, mass) in enumerate(particle_masses.items()):
+        particle_masses_evolution[j, 0] = particle_masses_array[j]  # Initialize mass
+        particle_speeds[j, 0] = particle_speed_initial  # Initialize speed
+        particle_temperatures[j, 0] = temperature_initial  # Initialize temperature
+        
+        for i in range(1, num_steps):
+            # Update temperature based on expansion of the universe
+            particle_temperatures[j, i] = particle_temperatures[j, i-1] * (1 - Hubble_constant_SI * t_planck)
+            
+            # Update speed using TSR
+            particle_speeds[j, i] = update_speed(particle_speeds[j, i-1], particle_temperatures[j, i], particle_masses_array[j])
+            
+            # Apply tunneling effect
+            if np.random.rand() < tunneling_probability:
+                particle_speeds[j, i] = particle_speeds[j, 0]
+                tunneling_steps[j, i] = True
+            
+            # Update mass based on energy conversion
+            energy_diff = relativistic_energy(particle_speeds[j, i], particle_masses_array[j]) - relativistic_energy(particle_speeds[j, i - 1], particle_masses_array[j])
+            particle_masses_evolution[j, i] = particle_masses_evolution[j, i - 1] + energy_diff / c**2
+            
+            # Check for collisions and handle them
+            collision, idx1, idx2 = check_collision(particle_speeds[:, i], collision_distance)
+            if collision:
+                handle_collision(particle_speeds[:, i], particle_masses_array, idx1, idx2)
+
+    # Print calculated masses at the end of the simulation
+    print(f"Calculated masses at the end of the simulation at the colision (Tunneling Probability: {tunneling_probability}):")
+    for j, particle in enumerate(particle_masses.keys()):
+        print(f"{particle}: {particle_masses_evolution[j, -1] / GeV_to_J:.4e} GeV")
+
+    # Save data to JSON file
+    data_filename = os.path.join(data_dir, f"big_bang_simulation_data_{tunneling_probability:.2f}.json")
+    data = {
+        "tunneling_probability": tunneling_probability,
+        "particle_masses_evolution": particle_masses_evolution.tolist(),
+        "particle_speeds": particle_speeds.tolist(),
+        "particle_temperatures": particle_temperatures.tolist(),
+        "tunneling_steps": tunneling_steps.tolist()
+    }
+    with open(data_filename, "w") as f:
+        json.dump(data, f)

simE.py

@@ -0,0 +1,173 @@
+import numpy as np
+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  # Convert to SI units (s^-1)
+
+# Initial conditions
+temperature_initial = 1.0  # Planck temperature in K
+particle_density_initial = 5.16e96  # Planck density in kg/m^3
+particle_speed_initial = TSR * temperature_initial  # Initial speed based on TSR
+
+# Simulation time
+t_planck = 5.39e-44  # Planck time in s
+t_simulation = t_planck * 1e5  # Shorter timescale for simulation
+
+# Updated particle masses (in GeV)
+particle_masses = {
+    "up": 2.3e-3,
+    "down": 4.8e-3,
+    "charm": 1.28,
+    "strange": 0.095,
+    "top": 173.0,
+    "bottom": 4.18,
+    "electron": 5.11e-4,
+    "muon": 1.05e-1,
+    "tau": 1.78,
+    "photon": 0,
+    "electron_neutrino": 0,  # Neutrinos have very small masses
+    "muon_neutrino": 0,
+    "tau_neutrino": 0,
+    "W_boson": 80.379,
+    "Z_boson": 91.1876,
+    "Higgs_boson": 125.1,
+    "gluon": 0,  # Massless
+    "proton": 0.938,
+    "neutron": 0.939,
+    "pion_plus": 0.140,
+    "pion_zero": 0.135,
+    "kaon_plus": 0.494,
+    "kaon_zero": 0.498
+}
+
+# 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.5, 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 and collisions
+def relativistic_energy(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * c**2 / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def relativistic_momentum(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * particle_speed / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def update_speed(current_speed, current_temperature, particle_mass):
+    """Update the speed of a particle based on temperature and mass."""
+    return TSR * current_temperature  # Update speed using TSR
+
+def check_collision(particle_speeds, collision_distance):
+    epsilon = 1e-15  # A small value to avoid invalid subtraction
+    for j in range(len(particle_speeds)):
+        for k in range(j+1, len(particle_speeds)):
+            if np.abs(particle_speeds[j] - particle_speeds[k]) < collision_distance + epsilon:
+                return True, j, k
+    return False, -1, -1
+
+def handle_collision(particle_speeds, particle_masses, idx1, idx2, current_step):
+    """Handle a collision between two particles."""
+    if particle_masses[idx1] == 0 or particle_masses[idx2] == 0:
+        # Skip handling collisions involving massless particles
+        return
+
+    p1 = relativistic_momentum(particle_speeds[idx1, current_step], particle_masses[idx1])
+    p2 = relativistic_momentum(particle_speeds[idx2, current_step], particle_masses[idx2])
+
+    # Calculate velocities after collision using conservation of momentum
+    total_momentum = p1 + p2
+    total_mass = particle_masses[idx1] + particle_masses[idx2]
+    v1_new = (total_momentum / total_mass) * (particle_masses[idx1] / total_mass)
+    v2_new = (total_momentum / total_mass) * (particle_masses[idx2] / total_mass)
+
+    particle_speeds[idx1, current_step], particle_speeds[idx2, current_step] = v1_new, v2_new
+
+
+# Simulate the Big Bang with Dark Energy, Dark Matter, Tunneling, Relativistic Effects, Redshift, and Entanglement
+for tunneling_probability in tunneling_probabilities:
+    print(f"Simulating for tunneling probability: {tunneling_probability}")
+
+    # Initialize arrays for simulation
+    num_particles = len(particle_masses)
+    particle_speeds = np.zeros((num_particles, num_steps))  # 2D array for speeds
+    particle_temperatures = np.zeros((num_particles, num_steps))  # 2D array for temperatures
+    particle_masses_evolution = np.zeros((num_particles, num_steps))  # 2D array for mass evolution
+    tunneling_steps = np.zeros((num_particles, num_steps), dtype=bool)  # 2D array for tunneling steps
+    particle_momentum = np.zeros((num_particles, num_steps))  # 2D array for momentum
+    total_energy = np.zeros(num_steps)  # 1D array for total energy of the system
+    redshifts = np.zeros((num_particles, num_steps))  # 2D array for redshift
+    entanglement_entropies = np.zeros((num_particles, num_steps))  # 2D array for entanglement entropy
+    particle_states = np.random.rand(num_particles, num_steps)  # Placeholder for particle states
+
+    # Create an array of masses for each particle
+    particle_masses_array = np.array([mass * GeV_to_J for mass in particle_masses.values()])
+
+    for j, (particle, mass) in enumerate(particle_masses.items()):
+        particle_speeds[j, 0] = particle_speed_initial  # Initialize speed
+        particle_masses_evolution[j, 0] = mass * GeV_to_J  # Initialize mass evolution
+
+    for current_step in range(1, num_steps):
+        for j in range(num_particles):
+            # Update temperature based on expansion of the universe
+            particle_temperatures[j, current_step] = particle_temperatures[j, current_step-1] * (1 - Hubble_constant_SI * t_planck)
+
+            # Update speed using TSR
+            particle_speeds[j, current_step] = update_speed(particle_speeds[j, current_step-1], particle_temperatures[j, current_step], particle_masses_array[j])
+
+            # Apply tunneling effect
+            if np.random.rand() < tunneling_probability:
+                particle_speeds[j, current_step] = particle_speeds[j, 0]
+                tunneling_steps[j, current_step] = True
+
+            # Calculate redshift
+            redshifts[j, current_step] = (1 + particle_speeds[j, current_step] / c)
+
+            # Calculate entanglement entropy
+            entanglement_entropies[j, current_step] = -np.sum(particle_states[j, current_step] * np.log(particle_states[j, current_step]))
+
+            # Update mass evolution
+            particle_masses_evolution[j, current_step] = particle_masses_evolution[j, current_step-1] * (1 - dark_energy_density * t_planck)
+
+        # Check for collisions
+        collision_detected, idx1, idx2 = check_collision(particle_speeds[:, current_step], collision_distance)
+        if collision_detected:
+            handle_collision(particle_speeds, particle_masses_array, idx1, idx2, current_step)
+
+    # 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, particle in enumerate(particle_masses.keys()):
+        print(f"{particle}: {particle_masses_evolution[j, -1] / GeV_to_J:.4e} GeV")
+
+    # Save data to JSON file
+    data_filename = os.path.join(data_dir, f"big_bang_simulation_data_{tunneling_probability:.2f}.json")
+    data = {
+        "tunneling_probability": tunneling_probability,
+        "particle_masses_evolution": particle_masses_evolution.tolist(),
+        "particle_speeds": particle_speeds.tolist(),
+        "particle_temperatures": particle_temperatures.tolist(),
+        "tunneling_steps": tunneling_steps.tolist(),
+        "redshifts": redshifts.tolist(),
+        "entanglement_entropies": entanglement_entropies.tolist()
+    }
+    with open(data_filename, "w") as f:
+        json.dump(data, f)

simZ.py

@@ -0,0 +1,142 @@
+import numpy as np
+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  # Convert to SI units (s^-1)
+
+# Initial conditions
+temperature_initial = 1.0  # Planck temperature in K
+particle_density_initial = 5.16e96  # Planck density in kg/m^3
+particle_speed_initial = TSR * temperature_initial  # Initial speed based on TSR
+
+# Simulation time
+t_planck = 5.39e-44  # Planck time in s
+t_simulation = t_planck * 1e5  # 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,
+    "electron": 5.11e-4,
+    "muon": 1.05e-1,
+    "tau": 1.78,
+    "photon": 0,
+}
+
+# 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.5, 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 and collisions
+def relativistic_energy(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * c**2 / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def relativistic_momentum(particle_speed, particle_mass):
+    epsilon = 1e-15  # A small value to avoid division by zero
+    return particle_mass * particle_speed / np.sqrt(max(1e-15, 1 - (particle_speed / c) ** 2 + epsilon))
+
+def update_speed(current_speed, current_temperature, particle_mass):
+    """Update the speed of a particle based on temperature and mass."""
+    return TSR * current_temperature  # Update speed using TSR
+
+def check_collision(particle_speeds, collision_distance):
+    epsilon = 1e-15  # A small value to avoid invalid subtraction
+    for j in range(len(particle_speeds)):
+        for k in range(j+1, len(particle_speeds)):
+            if np.abs(particle_speeds[j] - particle_speeds[k]) < collision_distance + epsilon:
+                return True, j, k
+    return False, -1, -1
+
+def handle_collision(particle_speeds, particle_masses, idx1, idx2):
+    """Handle a collision between two particles."""
+    p1 = relativistic_momentum(particle_speeds[idx1], particle_masses[idx1])
+    p2 = relativistic_momentum(particle_speeds[idx2], particle_masses[idx2])
+    
+    # Calculate velocities after collision using conservation of momentum
+    total_momentum = p1 + p2
+    total_mass = particle_masses[idx1] + particle_masses[idx2]
+    v1_new = (total_momentum / total_mass) * (particle_masses[idx1] / total_mass)
+    v2_new = (total_momentum / total_mass) * (particle_masses[idx2] / total_mass)
+    
+    particle_speeds[idx1], particle_speeds[idx2] = v1_new, v2_new
+
+# Simulate the Big Bang with Dark Energy, Dark Matter, Tunneling, and Relativistic Effects
+for tunneling_probability in tunneling_probabilities:
+    print(f"Simulating 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
+    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_speeds[j, 0] = particle_speed_initial  # Initialize speed
+        particle_temperatures[j, 0] = temperature_initial  # Initialize temperature
+        
+        for i in range(1, num_steps):
+            # Update temperature based on expansion of the universe
+            particle_temperatures[j, i] = particle_temperatures[j, i-1] * (1 - Hubble_constant_SI * t_planck)
+            
+            # Update speed using TSR
+            particle_speeds[j, i] = update_speed(particle_speeds[j, i-1], particle_temperatures[j, i], particle_masses[j])
+            
+            # Apply tunneling effect
+            if np.random.rand() < tunneling_probability:
+                particle_speeds[j, i] = particle_speeds[j, 0]
+                tunneling_steps[j, i] = True
+            
+            # Update mass based on energy conversion
+            energy_diff = relativistic_energy(particle_speeds[j, i], particle_masses[j]) - relativistic_energy(particle_speeds[j, i - 1], particle_masses[j])
+            particle_masses_evolution[j, i] = particle_masses_evolution[j, i - 1] + energy_diff / c**2
+            
+            # Check for collisions and handle them
+            collision, idx1, idx2 = check_collision(particle_speeds[:, i], collision_distance)
+            if collision:
+                handle_collision(particle_speeds[:, i], particle_masses, idx1, idx2)
+
+    # Print calculated masses at the end of the simulation
+    print(f"Calculated masses at the end of the simulation at the colision (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")
+
+    # Save data to JSON file
+    data_filename = os.path.join(data_dir, f"big_bang_simulation_data_{tunneling_probability:.2f}.json")
+    data = {
+        "tunneling_probability": tunneling_probability,
+        "particle_masses_evolution": particle_masses_evolution.tolist(),
+        "particle_speeds": particle_speeds.tolist(),
+        "particle_temperatures": particle_temperatures.tolist(),
+        "tunneling_steps": tunneling_steps.tolist()
+    }
+    with open(data_filename, "w") as f:
+        json.dump(data, f)

sting.py

@@ -0,0 +1,48 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Constants
+c = 299792458  # Speed of light in m/s
+hbar = 1.0545718e-34  # Reduced Planck constant in J·s
+alpha = 1.0  # Fine-structure constant
+
+# Define string properties
+string_length = 1e-35  # Length of the string in meters
+string_tension = 1e30  # Tension of the string in N
+
+# Define initial conditions
+initial_position = 0.0  # Initial position of the string
+initial_velocity = 1e6  # Initial velocity of the string
+
+# Simulation parameters
+time_step = 5.39e-44 * 1e3  # Time step for the simulation
+total_time = 5.39e-44  # Total simulation time
+
+# Initialize arrays to store position and velocity data
+num_steps = int(total_time / time_step) + 1
+position = np.zeros(num_steps)
+velocity = np.zeros(num_steps)
+
+# Set initial conditions
+position[0] = initial_position
+velocity[0] = initial_velocity
+
+# Main simulation loop
+for i in range(1, num_steps):
+    # Calculate acceleration using string equation of motion
+    acceleration = -(string_tension / hbar) * position[i - 1]
+    
+    # Update velocity and position
+    velocity[i] = velocity[i - 1] + acceleration * time_step
+    position[i] = position[i - 1] + velocity[i] * time_step
+
+# Plot the results
+plt.figure(figsize=(10, 6))
+plt.plot(np.arange(num_steps) * time_step, position, label="String Position")
+plt.xlabel("Time (s)")
+plt.ylabel("Position (m)")
+plt.title("String Evolution in Time")
+plt.grid(True)
+plt.legend()
+plt.show()
+

str.py

@@ -0,0 +1,48 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Constants
+c = 299792458  # Speed of light in m/s
+hbar = 1.0545718e-34  # Reduced Planck constant in J·s
+alpha = 1.0  # Fine-structure constant
+
+# Define string properties
+string_length = 1e-35  # Length of the string in meters
+string_tension = 1e30  # Tension of the string in N
+
+# Define initial conditions
+initial_position = 0.0  # Initial position of the string
+initial_velocity = 1e6  # Initial velocity of the string
+
+# Simulation parameters
+time_step = 5.39e-44 * 1e3  # Time step for the simulation
+total_time = 1e-40  # Extended total simulation time
+
+# Initialize arrays to store position and velocity data
+num_steps = int(total_time / time_step) + 1
+position = np.zeros(num_steps)
+velocity = np.zeros(num_steps)
+
+# Set initial conditions
+position[0] = initial_position
+velocity[0] = initial_velocity
+
+# Main simulation loop
+for i in range(1, num_steps):
+    # Calculate acceleration using string equation of motion
+    acceleration = -(string_tension / hbar) * position[i - 1]
+    
+    # Update velocity and position
+    velocity[i] = velocity[i - 1] + acceleration * time_step
+    position[i] = position[i - 1] + velocity[i] * time_step
+
+# Plot the results
+plt.figure(figsize=(10, 6))
+plt.plot(np.arange(num_steps) * time_step, position, label="String Position")
+plt.xlabel("Time (s)")
+plt.ylabel("Position (m)")
+plt.title("String Evolution in Time")
+plt.grid(True)
+plt.legend()
+plt.show()
+

test.py

@@ -0,0 +1,125 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+import cupy as cp
+from tqdm import tqdm
+import plotly.graph_objects as go
+import streamlit as st
+
+x = st.slider('Select a value')
+st.write(x, 'squared is', x * x)
+
+# Define the twelfth root of two
+Q = 2 ** (1/12)
+
+# Define the wave function of the universe with variants (using CuPy)
+def wave_function_cupy(x, t, scale=1.0, phase_shift=0.0):
+    denominator = 2 * (t**2 + 1e-10)  # Add a small value to avoid division by zero
+    return scale * Q * cp.exp(-x**2 / denominator) * cp.exp(-1j * (t + phase_shift))
+
+# Simulation parameters
+x = np.linspace(-10, 10, 100)
+t = np.linspace(0, 10, 100)
+X, T = np.meshgrid(x, t)
+
+# Convert numpy arrays to CuPy arrays
+X_cupy = cp.asarray(X)
+T_cupy = cp.asarray(T)
+
+# Variants parameters
+scales = [0.5, 1.0, 1.5]  # Different scaling factors
+phase_shifts = [0, np.pi/4, np.pi/2]  # Different phase shifts
+
+# Initialize a 3D array to store results
+wave_functions_3d = np.zeros((len(scales), len(phase_shifts), len(x), len(t)), dtype=complex)
+
+# Simulate with variants and store results in the 3D array
+for i, scale in enumerate(scales):
+    for j, phase_shift in enumerate(phase_shifts):
+        wave_functions_3d[i, j, :, :] = cp.asnumpy(wave_function_cupy(X_cupy, T_cupy, scale, phase_shift))
+
+# --- Plotly Interactive Visualization ---
+
+# Create the figure
+fig = go.Figure(data=[
+    go.Surface(x=x, y=t, z=np.abs(wave_functions_3d[0, 0, :, :])**2)
+])
+
+fig.update_layout(
+    title="Wave Function of the Universe",
+    scene=dict(
+        xaxis_title="x",
+        yaxis_title="t",
+        zaxis_title="|ψ(x,t)|^2"
+    ),
+)
+
+# Add Scale Slider
+fig.update_layout(
+    sliders=[
+        dict(
+            active=True,
+            currentvalue=dict(
+                prefix="Scale: ",
+                font=dict(size=12)
+            ),
+            steps=[
+                dict(
+                    method="update",
+                    args=[
+                        {"z": [np.abs(wave_functions_3d[i, 0, :, :])**2]}  # Update z data
+                    ],
+                    label=f"Scale: {scales[i]:.2f}"  # Label for step values
+                ) for i in range(len(scales))
+            ],
+            pad=dict(t=50),
+            len=0.9,  # Length of the slider
+            x=0.1,    # X position of the slider
+            y=0.1,    # Y position of the slider
+        ),
+        dict(
+            active=True,
+            currentvalue=dict(
+                prefix="Phase Shift: ",
+                font=dict(size=12)
+            ),
+            steps=[
+                dict(
+                    method="update",
+                    args=[
+                        {"z": [np.abs(wave_functions_3d[0, j, :, :])**2]}  # Update z data
+                    ],
+                    label=f"Phase Shift: {phase_shifts[j]:.2f}"  # Label for step values
+                ) for j in range(len(phase_shifts))
+            ],
+            pad=dict(t=50),
+            len=0.9,  # Length of the slider
+            x=0.1,    # X position of the slider
+            y=0.3,    # Y position of the slider
+        )
+    ]
+)
+
+fig.show()
+
+# --- End of Plotly ---
+
+# --- Matplotlib Animation ---
+
+# Animation
+fig, ax = plt.subplots()
+im = ax.imshow(np.abs(wave_functions_3d[0, 0, :, :]) ** 2, extent=[-10, 10, 0, 10], aspect='auto', cmap='viridis')
+ax.set_xlabel('x')
+ax.set_ylabel('t')
+ax.set_title('Wave Function of the Universe')
+cbar = fig.colorbar(im, ax=ax, label='|ψ(x,t)|^2')
+
+def update(frame):
+    i, j = divmod(frame, len(phase_shifts))  # Get the index for the 3D array
+    im.set_array(np.abs(wave_functions_3d[i, j, :, :]) ** 2)  # Update with the correct frame
+    ax.set_title(f'Wave Function at Scale: {scales[i]}, Phase Shift: {phase_shifts[j]:.2f}')
+    return im,
+
+ani = FuncAnimation(fig, update, frames=len(scales) * len(phase_shifts), blit=True)
+ani.save('wave_function_animation.gif', writer='pillow')
+plt.show()