Before LZ simulator interactive

Unified Oscillatory Field Theory and 3DCOM Framework

The recursions in3DCOM stabilize at LZ ( Loop Zero)= 1.23498228

3DCOM LZ constant
python:
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

Function to generate Collatz sequence for a number

def generate_collatz_sequence(n):
sequence = [n]
while n != 1:
if n % 2 == 0:
n = n // 2
else:
n = 3 * n + 1
sequence.append(n)
return sequence

Function to reduce numbers to a single-digit using modulo 9 (octave reduction)

def reduce_to_single_digit(value):
return (value - 1) % 9 + 1

Function to map reduced values to an octave structure

def map_to_octave(value, layer):
angle = (value / 9) * 2 * np.pi # Mapping to a circular octave
x = np.cos(angle) * (layer + 1)
y = np.sin(angle) * (layer + 1)
return x, y

Generate Collatz sequences for numbers 1 to 20

collatz_data = {n: generate_collatz_sequence(n) for n in range(1, 21)}

Map sequences to the octave model with reduction

octave_positions = {}
num_layers = max(len(seq) for seq in collatz_data.values())
stack_spacing = 1.0 # Space between layers

for number, sequence in collatz_data.items():
mapped_positions = []
for layer, value in enumerate(sequence):
reduced_value = reduce_to_single_digit(value)
x, y = map_to_octave(reduced_value, layer)
z = layer * stack_spacing # Layer height in 3D
mapped_positions.append((x, y, z))
octave_positions[number] = mapped_positions

Plot the 3D visualization

fig = plt.figure(figsize=(12, 10))
ax = fig.add_subplot(111, projection='3d')

Plot each Collatz sequence as a curve

for number, positions in octave_positions.items():
x_vals = [pos[0] for pos in positions]
y_vals = [pos[1] for pos in positions]
z_vals = [pos[2] for pos in positions]
ax.plot(x_vals, y_vals, z_vals, label=f"Collatz {number}")
ax.scatter(x_vals, y_vals, z_vals, s=20, zorder=5) # Points for clarity

Add labels and adjust the view

ax.set_title("3D Collatz Sequences in Octave Model")
ax.set_xlabel("X (Horizontal Oscillation)")
ax.set_ylabel("Y (Vertical Oscillation)")
ax.set_zlabel("Z (Octave Layer)")
plt.legend(loc='upper right', fontsize='small')

Show the plot

plt.show()

run this after:

import numpy as np
import matplotlib.pyplot as plt

Define the number of iterations (nested loops) to compute

num_iterations = 100

Initialize the wave function values

psi_values = np.zeros(num_iterations)
psi_values[0] = 1 # Initial condition

Compute the evolution of the recursive wave equation

for i in range(1, num_iterations):
psi_values[i] = np.sin(psi_values[i-1]) + np.exp(-psi_values[i-1])

Plot the evolution of the recursive COM function

plt.figure(figsize=(8, 4))
plt.plot(range(num_iterations), psi_values, marker="o", linestyle="-", color="blue", label="Ψ(n) Evolution")
plt.xlabel("Recursion Level (n)")
plt.ylabel("Wave Function Ψ(n)")
plt.title("COM Recursive Wave Function Evolution")
plt.legend()
plt.grid(True)
plt.show()

Display the computed recursive values

print("Computed Ψ(n) values:")
print(psi_values)

we get:

print(psi_values)
[1. 1.20935043 1.23377754 1.23493518 1.23498046 1.23498221
1.23498228 1.23498228 1.23498228 1.23498228 1.23498228 1.23498228
1.23498228 1.23498228 1.23498228 1.23498228 1.23498228 1.23498228

We see LZ as threshold attractor where particles/planets, etc...mass emerge.
But before LZ we calculate 5 single values for recursions after 1.

This simulator help to research what happens before LZ.

Set intermediate values ... AND I RECOMMEND to keep HQS fixed= 0.235. If you change HQS the 3DCOM structure collapse.
HQS is the threshold energy dump for recursions.
LZ point to stable energy density that we see it as matter.

The intermediate values have to be studied as fields. We do not have vacuum.