Hyper-Triskelion (4-D Parametric Family)

Description

Methods (English)

This work introduces v2.0 of the Stone–Hyper-Triskelion, extending the original 4-dimensional parametric structure into a fully coupled, multi-feedback dynamical system. The v1 model defined a 4D triskelion using a time-inversion term (δₜ = t_future − t), asymmetric rotational phases, and a dual-frequency vertical component (z,w). In v2.0, the structure is expanded into a mathematically adaptive 4D organism, where geometric evolution is shaped by interacting feedback mechanisms.

This updated formulation incorporates:
• Oscillating temporal horizon t_future(t)
• Radius modulation through exponential ε-driven variation
• Phase-coupled time inversion δₜ(φ,t)
• Angular feedback δₜ(θ,t) producing directional modulation
• Radial–temporal gain feedback via μ(r,t)
• Angular–radial gain coupling via λ(θ,t)
• Noise-tuned stochastic adjustment via ν(ε)
• Higher vertical frequency splitting in the (z,w) channel

These interactions produce a rich family of behaviors including breathing shells, vortex-like curvature flows, recursive knotting, quasi-periodic patterns, and chaotic transitions, all within a purely mathematical 4-dimensional coordinate system. No physical processes are implied, and the system remains fully consistent with classical physics and mathematical dynamical systems theory.

The v2.0 package includes consolidated reference equations, projection figures (2D and 3D), and a reproducible Python simulation environment, enabling further exploration and study of multi-feedback, high-dimensional parametric organisms.

(1) Base System — ASCII Version
------------------------------------------------------------
delta_t = t_future - t
(where t_future = 2, r = 1, and t runs from 1 → 0)

x(theta, phi, t) = (r + delta_t * cos(theta)) * cos(theta + phi + sin(delta_t))

y(theta, phi, t) = (r + delta_t * cos(theta)) * sin(theta + phi + sin(delta_t))

z(theta, phi, t) = delta_t * sin(theta) + cos(theta / 2)

w(theta, phi, t) = delta_t * sin(theta / 2)

Arms:
phi = 0, 2*pi/3, 4*pi/3

------------------------------------------------------------
(1b) Base System — Greek-Letter Version
------------------------------------------------------------
δₜ = t_future − t
(r = 1,  t_future = 2)

x(θ, φ, t) = (r + δₜ · cosθ) · cos(θ + φ + sin(δₜ))

y(θ, φ, t) = (r + δₜ · cosθ) · sin(θ + φ + sin(δₜ))

z(θ, φ, t) = δₜ · sinθ + cos(θ / 2)

w(θ, φ, t) = δₜ · sin(θ / 2)

Arms:
φ ∈ {0, 2π/3, 4π/3}

============================================================
(2) Extended Feedback-Coupled System — ASCII Version
============================================================

t_future(t) = 2 + 0.5 * sin(2*pi*t)

epsilon(theta, t) = 0.1 * sin(3*theta + 2*pi*t)

r(theta, t) = (1 + 0.3 * sin(2*pi*t)) * exp( epsilon(theta, t) * sin(theta) )

mu(r, t) = 0.2 + 0.1 * sin(r + pi*t)

lambda(theta, t) = 0.1 + 0.2 * sin(4*theta + pi*t)

nu(epsilon) = 0.15 + 0.1 * epsilon

delta_t(theta, phi, t) =
    ( t_future(t) - t )
    * (1 + 0.2 * sin(phi + pi*t))
    * (1 + mu(r, t) * sin(2*theta + pi*t))
    * (1 + lambda(theta, t) * sin(r))
    + 0.1 * nu(epsilon) * epsilon

x = (r + delta_t * cos(theta)) * cos(theta + phi + sin(delta_t))

y = (r + delta_t * cos(theta)) * sin(theta + phi + sin(delta_t))

z = delta_t * sin(theta) + cos(k_vert * theta / 2)

w = delta_t * sin(k_vert * theta / 2)

(where k_vert = 3 in the extended model)

============================================================
(2b) Extended Feedback-Coupled System — Greek-Letter Version
============================================================

t_future(t) = 2 + 0.5 · sin(2πt)

ε(θ, t) = 0.1 · sin(3θ + 2πt)

r(θ, t) = (1 + 0.3 · sin(2πt)) · exp( ε(θ, t) · sinθ )

μ(r, t) = 0.2 + 0.1 · sin(r + πt)

λ(θ, t) = 0.1 + 0.2 · sin(4θ + πt)

ν(ε) = 0.15 + 0.1ε

δₜ(θ, φ, t) =
    ( t_future(t) − t )
    · (1 + 0.2 · sin(φ + πt))
    · (1 + μ(r,t) · sin(2θ + πt))
    · (1 + λ(θ,t) · sin(r))
    + 0.1 · ν(ε) · ε

x(θ, φ, t) = (r + δₜ · cosθ) · cos(θ + φ + sin(δₜ))

y(θ, φ, t) = (r + δₜ · cosθ) · sin(θ + φ + sin(δₜ))

z(θ, φ, t) = δₜ · sinθ + cos(k_vert · θ / 2)

w(θ, φ, t) = δₜ · sin(k_vert · θ / 2)

(k_vert = 3 for the extended organism system)

Authored by Shane Edward Stone 

Simulations conducted by AI collaborator Kaelen. 

Licensed under Creative Commons Attribution 4.0 International (CC BY 4.0).

Methods (English)

# ===============================================================
# Stone Hyper-Triskelion v2.0
# Fully Coupled 4D Organism — Reproducible Python Code
# ===============================================================

import numpy as np
import matplotlib.pyplot as plt

# -----------------------------
# Parameter ranges
# -----------------------------
theta = np.linspace(0, 2*np.pi, 2500)
t_vals = np.linspace(0, 1, 120)
phi_vals = [0, 2*np.pi/3, 4*np.pi/3]

# Vertical frequency
k_vert = 3

# -----------------------------
# Coupling functions (ASCII form of Greek letters)
# -----------------------------

def t_future(t):
    return 2 + 0.5 * np.sin(2*np.pi*t)

def epsilon(theta, t):
    return 0.1 * np.sin(3*theta + 2*np.pi*t)

def r_func(theta, t):
    return (1 + 0.3*np.sin(2*np.pi*t)) * np.exp(epsilon(theta,t) * np.sin(theta))

def mu(r, t):
    return 0.2 + 0.1 * np.sin(r + np.pi*t)

def lam(theta, t):
    return 0.1 + 0.2 * np.sin(4*theta + np.pi*t)

def nu(eps):
    return 0.15 + 0.1*eps

# -----------------------------
# Fully coupled delta_t
# -----------------------------
def delta_t(theta, phi, t):
    tf = t_future(t)
    eps = epsilon(theta, t)
    r = r_func(theta, t)
    return ((tf - t)
            * (1 + 0.2*np.sin(phi + np.pi*t))
            * (1 + mu(r, t)*np.sin(2*theta + np.pi*t))
            * (1 + lam(theta, t)*np.sin(r))
            + 0.1*nu(eps)*eps)

# -----------------------------
# Final 4D coordinates
# -----------------------------
def coords(theta, phi, t):
    dt = delta_t(theta, phi, t)
    r = r_func(theta, t)
    x = (r + dt*np.cos(theta)) * np.cos(theta + phi + np.sin(dt))
    y = (r + dt*np.cos(theta)) * np.sin(theta + phi + np.sin(dt))
    z = dt*np.sin(theta) + np.cos(k_vert * theta / 2)
    w = dt*np.sin(k_vert * theta / 2)
    return x, y, z, w

# -----------------------------
# Visualization: 3D projection
# -----------------------------
fig = plt.figure(figsize=(10, 8))
ax = fig.add_subplot(111, projection='3d')

t_frame = 0.35   # Choose a time slice to visualize

for phi in phi_vals:
    x, y, z, w = coords(theta, phi, t_frame)
    ax.plot(x, y, z, linewidth=1.3)

ax.set_title("Stone–Kaelen Hyper-Triskelion v2.0 — Fully Coupled 4D Organism")
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.set_zlabel("z")
plt.tight_layout()
plt.show()

Licensed under Creative Commons Attribution 4.0 International (CC BY 4.0).

Methods (English)

Practical Applications of the Hyper-Triskelion 4D Feedback Model

The Hyper-Triskelion framework introduces a 4-dimensional parametric system with time-inversion, angular–radial feedback, and stochastic gain coupling.
Its mathematical structure has several concrete, high-value applications:

---

1. Geometry-Aware AI Models

Provides synthetic 4D attractor data for training neural nets on geometric reasoning.

Enables benchmarks for chaos-aware AI, useful for next-generation xAI- or DeepMind-style simulators.

Helps develop world-model architectures with better handling of curvature, topology, and high-dimensional dynamics.

---

2. Procedural Generation in Games, VR, and AR

Generates organic, evolving vortices and recursive 4D structures for environments and effects.

Useful for dynamic topology, “living geometry,” and non-repeating fractal patterns.

Perfect for VR/AR experiences that need nonlinear motion, “breathing” structures, or alien ecosystems.

---

3. Physics and Dynamical Systems Research

Serves as a sandbox for studying:

quasi-periodicity

mode-locking

multi-frequency coupling

chaotic attractor transitions

The model is a clean, accessible playground for chaos theorists and applied mathematicians.

---

4. Robotics and Motion Planning

The 4D parametric flows act as nonlinear trajectory fields.

Can be mapped into:

smooth collision-avoiding paths

adaptive navigation in uncertain environments

Particularly useful for drones, robotic arms, and motion-in-high-dimensional-spaces.

---

5. Data Compression & Topological Encoding

The feedback architecture creates stable-but-complex manifolds.

These can be used for:

topological compression,

noise-resistant signal encoding,

“shape signatures” for classification pipelines.

---

6. Scientific Visualization & Education

Generates visuals that naturally demonstrate:

4D geometry

dynamical folding

chaos transitions

parametric motion

Excellent for teaching nonlinear systems, topology, and multi-dimensional math.

---

7. AI-Generated Art & Animation

Produces “living fractal organisms” and evolving patterns ideal for:

sci-fi visual effects

music videos

procedural art

ambient generative worlds

Works beautifully with tools like Grok Imagine, RunwayML, Blender, and TouchDesigner.

---

8. Benchmark Suite for Stability Testing

The wide range of chaotic regimes provides a stress test for:

numerical solvers

integrators

dynamical simulators

physics engines

Helps identify when systems fail under nonlinear feedback.

---

9. Biologically Inspired Modeling

Although not a biological model, the dynamics resemble:

self-regulating oscillators

breathing cycles

precessing helices

recursive structural folding

This makes it useful as a template for more formal biological or ecological simulations.

---

10. Foundation for Future Mathematical Exploration

The system naturally opens new research pathways:

4D knot theory

time-inverted dynamical flows

feedback-coupled fractal manifolds

stochastic gain modulation in high-dimensional systems

Notes (English)

Methods (English)

"""
Hyper-Triskelion v2 — Feedback-Coupled 4D Parametric Simulator
Author: Shane Edward Stone
License: CC-BY-4.0

This script simulates the Hyper-Triskelion v2 model described on Zenodo:
- 4D parametric attractor with time-inversion
- Radial feedback via t_future(t)
- Phase-split z–w coordinates
- Three C3-symmetric arms (φ = 0, 2π/3, 4π/3)

It generates:
  • 4D coordinates (x, y, z, w) for each arm
  • A simple 3D projection (x, y, z) for visualization

You can tweak the parameters in MAIN PARAMETERS below to explore
different knotting / chaos regimes.
"""

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D  # noqa: F401  (needed for 3D)

# ===============================
# MAIN PARAMETERS
# ===============================

N_T      = 2000          # number of time steps
N_THETA  = 400           # angular resolution per arm
R0       = 1.0           # base radius
TFUTURE_BASE = 2.0       # baseline future horizon
TFUTURE_AMP  = 0.5       # amplitude of t_future oscillation
EPS_AMP      = 0.1       # amplitude of epsilon(θ, t)
NOISE_EPS    = 0.01      # stochastic term on epsilon
W_SPLIT      = 2.0       # frequency split in z,w (z uses θ/2, w uses W_SPLIT*θ/2)

# ===============================
# CORE MODEL
# ===============================

def t_future(t):
    """
    Future-horizon function t_future(t).
    Here we use a simple oscillatory form:

        t_future(t) = TFUTURE_BASE + TFUTURE_AMP * sin(2π t)

    with t ∈ [0, 1].
    """
    return TFUTURE_BASE + TFUTURE_AMP * np.sin(2.0 * np.pi * t)

def delta_t(t):
    """
    Time-inversion delta:
        δ_t = t_future(t) - t
    """
    return t_future(t) - t

def epsilon_theta_t(theta, t, rng=None):
    """
    Small modulation term ε(θ, t) for radial feedback.
    Deterministic part: EPS_AMP * sin(3θ + 2π t)
    Optional stochastic noise for chaos exploration.
    """
    base = EPS_AMP * np.sin(3.0 * theta + 2.0 * np.pi * t)
    if rng is None or NOISE_EPS <= 0.0:
        return base
    noise = NOISE_EPS * rng.normal(size=theta.shape)
    return base + noise

def hyper_triskelion_arm(theta, t, phi, rng=None):
    """
    Compute one arm of the Hyper-Triskelion in 4D:

        r(θ, t)   = R0 + δ_t cos θ · (1 + ε(θ, t))
        x(θ, φ, t) = r cos(θ + φ + sin δ_t)
        y(θ, φ, t) = r sin(θ + φ + sin δ_t)
        z(θ, t)    = δ_t sin θ + cos(θ / 2)
        w(θ, t)    = δ_t sin(θ / 2) + np.cos(W_SPLIT * theta / 2)

    where φ is the arm phase: 0, 2π/3, 4π/3.
    """
    dt = delta_t(t)
    eps = epsilon_theta_t(theta, t, rng=rng)

    r = R0 + dt * np.cos(theta) * (1.0 + eps)

    phase = theta + phi + np.sin(dt)
    x = r * np.cos(phase)
    y = r * np.sin(phase)

    z = dt * np.sin(theta) + np.cos(theta / 2.0)
    w = dt * np.sin(theta / 2.0) + np.cos(W_SPLIT * theta / 2.0)

    return x, y, z, w

def simulate_hyper_triskelion(n_t=N_T, n_theta=N_THETA, seed=42):
    """
    Simulate all three arms over time.

    Returns:
        coords_4d: list of length 3 (one per arm)
                   each element is dict with keys 'x','y','z','w',
                   each array of shape (n_t, n_theta)

    The arms use phases:
        φ0 = 0
        φ1 = 2π/3
        φ2 = 4π/3
    """
    rng = np.random.default_rng(seed)

    thetas = np.linspace(0.0, 2.0 * np.pi, n_theta, endpoint=False)
    ts = np.linspace(0.0, 1.0, n_t)

    phis = [0.0, 2.0 * np.pi / 3.0, 4.0 * np.pi / 3.0]

    coords_4d = []

    for phi in phis:
        x_arr = np.zeros((n_t, n_theta))
        y_arr = np.zeros((n_t, n_theta))
        z_arr = np.zeros((n_t, n_theta))
        w_arr = np.zeros((n_t, n_theta))

        for i, t in enumerate(ts):
            x, y, z, w = hyper_triskelion_arm(thetas, t, phi, rng=rng)
            x_arr[i, :] = x
            y_arr[i, :] = y
            z_arr[i, :] = z
            w_arr[i, :] = w

        coords_4d.append({
            "x": x_arr,
            "y": y_arr,
            "z": z_arr,
            "w": w_arr,
            "phi": phi
        })

    return coords_4d, ts, thetas

# ===============================
# SIMPLE VISUALIZATION
# ===============================

def plot_snapshot(coords_4d, ts, step=None):
    """
    Plot a single time snapshot in 3D (x, y, z) for all arms.

    Args:
        coords_4d: output from simulate_hyper_triskelion
        ts:        time array
        step:      index into ts; if None uses middle of trajectory
    """
    if step is None:
        step = len(ts) // 2

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

    colors = ["tab:orange", "tab:blue", "tab:green"]

    for arm_idx, (arm, c) in enumerate(zip(coords_4d, colors)):
        x = arm["x"][step, :]
        y = arm["y"][step, :]
        z = arm["z"][step, :]
        ax.plot(x, y, z, c=c, lw=1.0, label=f"arm {arm_idx}")

    ax.set_title(f"Hyper-Triskelion v2 snapshot at t ≈ {ts[step]:.3f}")
    ax.set_xlabel("x")
    ax.set_ylabel("y")
    ax.set_zlabel("z")
    ax.legend()
    plt.tight_layout()
    plt.show()

# ===============================
# MAIN
# ===============================

if __name__ == "__main__":
    coords_4d, ts, thetas = simulate_hyper_triskelion()
    # Show a mid-trajectory snapshot
    plot_snapshot(coords_4d, ts, step=len(ts) // 2)