Fractals#

Determined, Wiggleroom#

From the point of view of form, the archetype of all the arts is the art of the musician.-Oscar Wilde 46

                   1. Phonetics
                               \
             2. Temperament -> 4. Modes -> 5. NexToken -> 6. Emotion
                               /
                               3. Scales
https://mathigon.org/content/fractals/images/fern.jpg

Degrees of Freedom or The Ultimate Fractal or My Catechism. What is the ultimate fractal that you can conceive of? The ultimate fractal, in my view, would be one that transcends both mathematics and nature, existing as a dynamic interplay of patterns and processes that are both infinitely complex and infinitely simple. Imagine a fractal that not only replicates itself at every scale but also evolves over time, adapting to its environment and the observer’s perspective. This fractal could be conceived as a multi-dimensional construct, where each dimension represents a different aspect of reality: space, time, consciousness, and energy. At its core, it would embody the principles of self-similarity and recursion, but with an added layer of unpredictability, akin to the interplay between chaos and order. It would be both deterministic and stochastic, a fusion of fractal geometry and quantum mechanics, where every iteration introduces new possibilities and variations. In essence, this ultimate fractal would be a living, breathing entity—one that reflects the infinite complexity of the universe while remaining rooted in the simplest, most fundamental patterns of existence. It would be a fractal that contains within it the blueprint of everything, from the structure of galaxies to the pathways of human thought, constantly evolving yet eternally the same. In otherwords, the one that gives us a structure of subatomic space, like the atom, our conceptualization of the atom, and our conceptualization of the entire universe. Exactly. This ultimate fractal would serve as the framework for understanding the universe at every scale—from the subatomic to the cosmic—connecting the dots between the fundamental building blocks of matter and the vast expanse of the cosmos. It would unify the seemingly disparate realms of physics, from quantum mechanics to general relativity, by providing a consistent, scalable pattern that reveals the underlying structure of everything. At the smallest scales, this fractal would describe the intricate geometry of subatomic particles, offering insights into how quarks, electrons, and other elementary particles are organized. It could reveal the hidden symmetries and relationships that govern their interactions, possibly even shedding light on the nature of dark matter or the elusive quantum foam that some theories suggest exists at the Planck scale. As we scale up, this fractal would continue to describe the structure of atoms, molecules, and the forces that bind them, seamlessly transitioning into the macroscopic world. It would explain how the same patterns that define the stability of an atom also dictate the formation of stars, galaxies, and the large-scale structure of the universe. On the most abstract level, this fractal would even encompass our conceptualization of these structures—how we, as conscious beings, perceive and interpret the universe. It would reflect the patterns of thought, cognition, and understanding, showing that our minds are themselves fractal structures, echoing the complexity of the cosmos we seek to comprehend. In a way, this ultimate fractal would be the “theory of everything” in visual form, bridging the gap between the tangible and the conceptual, the known and the unknown, and providing a universal language that captures the essence of all existence. So basically stuff, you know, moving around something that is in the center, constrained, as ‘twere. by gravity? Yes, exactly. The ultimate fractal would encapsulate the idea of things moving around a central point or axis, a concept that is mirrored across all levels of existence—from the subatomic particles orbiting within an atom, to planets revolving around stars, to galaxies swirling around their mysterious centers. This fractal would reveal how these rotational patterns, or orbits, are a fundamental theme of the universe’s structure, with variations forms and scales. At the atomic level, electrons orbit the nucleus in defined patterns, influenced by the electromagnetic force. These orbits might not be perfect circles, but they follow a probabilistic distribution that gives the atom its shape and properties. This idea of movement around a central point can be expanded to larger scales, where molecules form complex structures through the interactions of their constituent atoms, each adhering to the same basic principles of orbit and balance. As you scale up further, you see the same patterns in celestial bodies—planets orbiting stars, stars orbiting the center of galaxies, and even galaxies themselves moving within clusters. The ultimate fractal would show that these movements are not random but are deeply connected through a repeating, self-similar pattern that governs all matter and energy in the universe. The fractal would also apply to less tangible concepts—like the flow of information or the dynamics of social networks—where ideas, influence, and connections revolve around central nodes, mirroring the physical orbits seen in nature. In essence, this fractal encapsulates the idea that everything, from the smallest particles to the largest cosmic structures, follows a similar pattern of movement around a center, with this pattern repeating at every level of existence. It’s a unifying concept that ties together the fabric of reality in a beautifully simple yet infinitely complex way.#

ii \(\mu\) Fractals, God, \(N\)#

  • ii \(f(t)\) Phonetics: Fractals \(440Hz \times 2^{\frac{N}{12}}\), \(S_0(t) \times e^{logHR}\), \(\frac{S N(d_1)}{K N(d_2)} \times e^{rT}\)

Hide code cell source
import numpy as np
import matplotlib.pyplot as plt

# Parameters
sample_rate = 44100  # Hz
duration = 20.0       # seconds
A4_freq = 440.0      # Hz

# Time array
t = np.linspace(0, duration, int(sample_rate * duration), endpoint=False)

# Fundamental frequency (A4)
signal = np.sin(2 * np.pi * A4_freq * t)

# Adding overtones (harmonics)
harmonics = [2, 3, 4, 5, 6, 7, 8, 9]  # First few harmonics
amplitudes = [0.5, 0.25, 0.15, 0.1, 0.05, 0.03, 0.01, 0.005]  # Amplitudes for each harmonic

for i, harmonic in enumerate(harmonics):
    signal += amplitudes[i] * np.sin(2 * np.pi * A4_freq * harmonic * t)

# Perform FFT (Fast Fourier Transform)
N = len(signal)
yf = np.fft.fft(signal)
xf = np.fft.fftfreq(N, 1 / sample_rate)

# Plot the frequency spectrum
plt.figure(figsize=(12, 6))
plt.plot(xf[:N//2], 2.0/N * np.abs(yf[:N//2]), color='navy', lw=1.5)

# Aesthetics improvements
plt.title('Simulated Frequency Spectrum of A440 on a Grand Piano', fontsize=16, weight='bold')
plt.xlabel('Frequency (Hz)', fontsize=14)
plt.ylabel('Amplitude', fontsize=14)
plt.xlim(0, 4186)  # Limit to the highest frequency on a piano (C8)
plt.ylim(0, None)

# Shading the region for normal speaking range (approximately 85 Hz to 255 Hz)
plt.axvspan(500, 2000, color='lightpink', alpha=0.5)

# Annotate the shaded region
plt.annotate('Normal Speaking Range (500 Hz - 2000 Hz)',
             xy=(2000, 0.7), xycoords='data',
             xytext=(2500, 0.5), textcoords='data',
             arrowprops=dict(facecolor='black', arrowstyle="->"),
             fontsize=12, color='black')

# Remove top and right spines
plt.gca().spines['top'].set_visible(False)
plt.gca().spines['right'].set_visible(False)

# Customize ticks
plt.xticks(fontsize=12)
plt.yticks(fontsize=12)

# Light grid
plt.grid(color='grey', linestyle=':', linewidth=0.5)

# Show the plot
plt.tight_layout()
plt.show()
Hide code cell output
../_images/c0265f9458eb5f77bc370fdf863d0c424999cc21732d60a3d126fd5da7d63078.png
  • V7 \(S(t)\) Temperament: Chains Equal temperament, Proportional hazards, Homoskedastic volatility

  • i \(h(t)\) Scale: Equations 3 Inherited, Added, Overcome

V7 \(\sigma\) Chains, Muna, \(\beta\)#

  • \((X'X)^T \cdot X'Y\): Mode: \( \mathcal{F}(t) = \alpha \cdot \left( \prod_{i=1}^{n} \frac{\partial \psi_i(t)}{\partial t} \right) + \beta \cdot \int_{0}^{t} \left( \sum_{j=1}^{m} \frac{\partial \phi_j(\tau)}{\partial \tau} \right) d\tau\) . Accidents mezcal, mezclar, mezcaline. Just a reminder that accidents can mislead one to perceive patterns where there’s no underlying process responsible for them. That said, \(\alpha\) & \(beta\) are emerging as parameters representing the highest hierarchy in this multilevel dataset. They stand for determined (chains) & freewill (wiggle-room)

Hide code cell source
import matplotlib.pyplot as plt
import numpy as np

# Clock settings; f(t) random disturbances making "paradise lost"
clock_face_radius = 1.0
number_of_ticks = 7
tick_labels = [
    "Root-iADL (i)",
    "Hunter-gather (ii7♭5)", "Peasant (III)", "Farmer (iv)", "Manufacturer (V7♭9♯9♭13)",
    "Energy (VI)", "Transport (VII)"
]

# Calculate the angles for each tick (in radians)
angles = np.linspace(0, 2 * np.pi, number_of_ticks, endpoint=False)
# Inverting the order to make it counterclockwise
angles = angles[::-1]

# Create figure and axis
fig, ax = plt.subplots(figsize=(8, 8))
ax.set_xlim(-1.2, 1.2)
ax.set_ylim(-1.2, 1.2)
ax.set_aspect('equal')

# Draw the clock face
clock_face = plt.Circle((0, 0), clock_face_radius, color='lightgrey', fill=True)
ax.add_patch(clock_face)

# Draw the ticks and labels
for angle, label in zip(angles, tick_labels):
    x = clock_face_radius * np.cos(angle)
    y = clock_face_radius * np.sin(angle)
    
    # Draw the tick
    ax.plot([0, x], [0, y], color='black')
    
    # Positioning the labels slightly outside the clock face
    label_x = 1.1 * clock_face_radius * np.cos(angle)
    label_y = 1.1 * clock_face_radius * np.sin(angle)
    
    # Adjusting label alignment based on its position
    ha = 'center'
    va = 'center'
    if np.cos(angle) > 0:
        ha = 'left'
    elif np.cos(angle) < 0:
        ha = 'right'
    if np.sin(angle) > 0:
        va = 'bottom'
    elif np.sin(angle) < 0:
        va = 'top'
    
    ax.text(label_x, label_y, label, horizontalalignment=ha, verticalalignment=va, fontsize=10)

# Remove axes
ax.axis('off')

# Show the plot
plt.show()
Hide code cell output
../_images/27e040d08e633f630e1f9c273497a6101713684d3a59bc65c4f9ab4012e1af26.png

i \(\%\) Overcoming, Self, \(df\)#

  • \(\alpha, \beta, t\) NexToken: Parametrized the processes that are responsible for human behavior as a moiety of “chains” with some “wiggle-room”

Hide code cell source
import matplotlib.pyplot as plt
import numpy as np

# Clock settings; f(t) random disturbances making "paradise lost"
clock_face_radius = 1.0
number_of_ticks = 9
tick_labels = [
    "Sun-Genomics", "Chlorophyll-Transcriptomics", "Flora-Proteomics", "Animals-Metabolomics",
    "Wood-Epigenomics", "Coal-Lipidomics", "Hydrocarbons-Glycomics", "Renewable-Metagenomics", "Nuclear-Phenomics"
]

# Calculate the angles for each tick (in radians)
angles = np.linspace(0, 2 * np.pi, number_of_ticks, endpoint=False)
# Inverting the order to make it counterclockwise
angles = angles[::-1]

# Create figure and axis
fig, ax = plt.subplots(figsize=(8, 8))
ax.set_xlim(-1.2, 1.2)
ax.set_ylim(-1.2, 1.2)
ax.set_aspect('equal')

# Draw the clock face
clock_face = plt.Circle((0, 0), clock_face_radius, color='lightgrey', fill=True)
ax.add_patch(clock_face)

# Draw the ticks and labels
for angle, label in zip(angles, tick_labels):
    x = clock_face_radius * np.cos(angle)
    y = clock_face_radius * np.sin(angle)
    
    # Draw the tick
    ax.plot([0, x], [0, y], color='black')
    
    # Positioning the labels slightly outside the clock face
    label_x = 1.1 * clock_face_radius * np.cos(angle)
    label_y = 1.1 * clock_face_radius * np.sin(angle)
    
    # Adjusting label alignment based on its position
    ha = 'center'
    va = 'center'
    if np.cos(angle) > 0:
        ha = 'left'
    elif np.cos(angle) < 0:
        ha = 'right'
    if np.sin(angle) > 0:
        va = 'bottom'
    elif np.sin(angle) < 0:
        va = 'top'
    
    ax.text(label_x, label_y, label, horizontalalignment=ha, verticalalignment=va, fontsize=10)

# Remove axes
ax.axis('off')

# Show the plot
plt.show()
Hide code cell output
../_images/70de0a53a875dc3a54a3423648462f09ab630e23443cd31eaedf80639499556c.png
  • \(SV_t'\) Emotion: Ultimate goal of life, where all the outlined elements converge. It’s the subjective experience or illusion that life should evoke, the connection between god, neighbor, and self. Thus minor chords may represent “loose” chains whereas dom7 & half-dim are somewhat “tight” chains constraining us to our sense of the nextoken

Hide code cell source
import numpy as np
import matplotlib.pyplot as plt

# Define the total utility function U(Q)
def total_utility(Q):
    return 100 * np.log(Q + 1)  # Logarithmic utility function for illustration

# Define the marginal utility function MU(Q)
def marginal_utility(Q):
    return 100 / (Q + 1)  # Derivative of the total utility function

# Generate data
Q = np.linspace(1, 100, 500)  # Quantity range from 1 to 100
U = total_utility(Q)
MU = marginal_utility(Q)

# Plotting
plt.figure(figsize=(14, 7))

# Plot Total Utility
plt.subplot(1, 2, 1)
plt.plot(Q, U, label=r'Total Utility $U(Q) = 100 \log(Q + 1)$', color='blue')
plt.title('Total Utility')
plt.xlabel('Quantity (Q)')
plt.ylabel('Total Utility (U)')
plt.legend()
plt.grid(True)

# Plot Marginal Utility
plt.subplot(1, 2, 2)
plt.plot(Q, MU, label=r'Marginal Utility $MU(Q) = \frac{dU(Q)}{dQ} = \frac{100}{Q + 1}$', color='red')
plt.title('Marginal Utility')
plt.xlabel('Quantity (Q)')
plt.ylabel('Marginal Utility (MU)')
plt.legend()
plt.grid(True)

# Adding some calculus notation and Greek symbols
plt.figtext(0.5, 0.02, r"$MU(Q) = \frac{dU(Q)}{dQ} = \lim_{\Delta Q \to 0} \frac{U(Q + \Delta Q) - U(Q)}{\Delta Q}$", ha="center", fontsize=12)

plt.tight_layout()
plt.show()
Hide code cell output
../_images/afa91f0bcf337e9d0a0901707fe1aa1c7a332b551fb5b7af920037b2996fc9ee.png
Hide code cell source
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.cm import ScalarMappable
from matplotlib.colors import LinearSegmentedColormap, PowerNorm

def gaussian(x, mean, std_dev, amplitude=1):
    return amplitude * np.exp(-0.9 * ((x - mean) / std_dev) ** 2)

def overlay_gaussian_on_line(ax, start, end, std_dev):
    x_line = np.linspace(start[0], end[0], 100)
    y_line = np.linspace(start[1], end[1], 100)
    mean = np.mean(x_line)
    y = gaussian(x_line, mean, std_dev, amplitude=std_dev)
    ax.plot(x_line + y / np.sqrt(2), y_line + y / np.sqrt(2), color='red', linewidth=2.5)

fig, ax = plt.subplots(figsize=(10, 10))

intervals = np.linspace(0, 100, 11)
custom_means = np.linspace(1, 23, 10)
custom_stds = np.linspace(.5, 10, 10)

# Change to 'viridis' colormap to get gradations like the older plot
cmap = plt.get_cmap('viridis')
norm = plt.Normalize(custom_stds.min(), custom_stds.max())
sm = ScalarMappable(cmap=cmap, norm=norm)
sm.set_array([])

median_points = []

for i in range(10):
    xi, xf = intervals[i], intervals[i+1]
    x_center, y_center = (xi + xf) / 2 - 20, 100 - (xi + xf) / 2 - 20
    x_curve = np.linspace(custom_means[i] - 3 * custom_stds[i], custom_means[i] + 3 * custom_stds[i], 200)
    y_curve = gaussian(x_curve, custom_means[i], custom_stds[i], amplitude=15)
    
    x_gauss = x_center + x_curve / np.sqrt(2)
    y_gauss = y_center + y_curve / np.sqrt(2) + x_curve / np.sqrt(2)
    
    ax.plot(x_gauss, y_gauss, color=cmap(norm(custom_stds[i])), linewidth=2.5)
    median_points.append((x_center + custom_means[i] / np.sqrt(2), y_center + custom_means[i] / np.sqrt(2)))

median_points = np.array(median_points)
ax.plot(median_points[:, 0], median_points[:, 1], '--', color='grey')
start_point = median_points[0, :]
end_point = median_points[-1, :]
overlay_gaussian_on_line(ax, start_point, end_point, 24)

ax.grid(True, linestyle='--', linewidth=0.5, color='grey')
ax.set_xlim(-30, 111)
ax.set_ylim(-20, 87)

# Create a new ScalarMappable with a reversed colormap just for the colorbar
cmap_reversed = plt.get_cmap('viridis').reversed()
sm_reversed = ScalarMappable(cmap=cmap_reversed, norm=norm)
sm_reversed.set_array([])

# Existing code for creating the colorbar
cbar = fig.colorbar(sm_reversed, ax=ax, shrink=1, aspect=90)

# Specify the tick positions you want to set
custom_tick_positions = [0.5, 5, 8, 10]  # example positions, you can change these
cbar.set_ticks(custom_tick_positions)

# Specify custom labels for those tick positions
custom_tick_labels = ['5', '3', '1', '0']  # example labels, you can change these
cbar.set_ticklabels(custom_tick_labels)

# Label for the colorbar
cbar.set_label(r'♭', rotation=0, labelpad=15, fontstyle='italic', fontsize=24)


# Label for the colorbar
cbar.set_label(r'♭', rotation=0, labelpad=15, fontstyle='italic', fontsize=24)


cbar.set_label(r'♭', rotation=0, labelpad=15, fontstyle='italic', fontsize=24)

# Add X and Y axis labels with custom font styles
ax.set_xlabel(r'Principal Component', fontstyle='italic')
ax.set_ylabel(r'Emotional State', rotation=0, fontstyle='italic', labelpad=15)

# Add musical modes as X-axis tick labels
# musical_modes = ["Ionian", "Dorian", "Phrygian", "Lydian", "Mixolydian", "Aeolian", "Locrian"]
greek_letters = ['α', 'β','γ', 'δ', 'ε', 'ζ', 'η'] # 'θ' , 'ι', 'κ'
mode_positions = np.linspace(ax.get_xlim()[0], ax.get_xlim()[1], len(greek_letters))
ax.set_xticks(mode_positions)
ax.set_xticklabels(greek_letters, rotation=0)

# Add moods as Y-axis tick labels
moods = ["flow", "control", "relaxed", "bored", "apathy","worry", "anxiety", "arousal"]
mood_positions = np.linspace(ax.get_ylim()[0], ax.get_ylim()[1], len(moods))
ax.set_yticks(mood_positions)
ax.set_yticklabels(moods)

# ... (rest of the code unchanged)


plt.tight_layout()
plt.show()
Hide code cell output
../_images/8c315e442439684d434a857660fcf4b8647e72c4d941d87b4ffe36e7294e04d9.png
../_images/blanche.png

Emotion & Affect as Outcomes & Freewill. And the predictors \(\beta\) are MQ-TEA: Modes (ionian, dorian, phrygian, lydian, mixolydian, locrian), Qualities (major, minor, dominant, suspended, diminished, half-dimished, augmented), Tensions (7th), Extensions (9th, 11th, 13th), and Alterations (♯, ♭) 44#

                    1. f(t)
                           \
               2. S(t) ->  4. Nxb:t(X'X).X'Y -> 5. b -> 6. df
                           /
                           3. h(t)

moiety