05/12/2025
nyissd ki a szemedöffne deine Augenopen your eyes
1. README – három nyelven (HU / DE / EN)
🇭🇺 README (magyar)
Projekt neve: WS-501 · A_KEREK_MASTER – Routed Mandala
Szerző: Balázs Maus (a CSŐ)
Rövid leírás
Ez a projekt egy egyetlen Python fájlban rögzíti a WS-501 rendszer egyik központi „artefaktját”:
a tökéletes számok első 12 elemét,
azok digitális gyökét (digital root),
a 1–9 közötti AXIOM KAPUKhoz való hozzárendelést,
egy routed mandala vizualizációt (Bezier-flow vonalakkal),
és egy CSV routing táblát, ami auditálható, újrahasználható adatbázist ad.
Mit csinál a kód?
1. Digital Root számítás:
Minden tökéletes számhoz kiszámolja a digitális gyökeret (1–9).
2. Kapukhoz rendelés (1–9 Axiom Gates):
A digital root határozza meg, melyik kapuhoz tartozik a szám:
DR Gate Név (magyar jelentés)
1 1 UNIT (egység)
2 2 BRIDGE (híd)
3 3 ROOT (gyökér)
4 4 4.VECTOR (vektor)
5 5 BALÁZS
6 6 CORE (mag)
7 7 EXPLORE (feltárás)
8 8 OCTAVE (oktáv)
9 9 CLOSURE (lezárás)
3. CSV export:
Létrejön egy ws501_routing_table.csv, benne minden perf. számmal, digitjeinek számával, digital root-tal, kapuszámmal, kapunévvel, timestamp-pel, hash-sel.
4. Vizualizáció (mandala):
Létrejön egy PNG kép (alapértelmezés: ws501_routed_mandala_final.png), amin:
középen a 4.V (4. vektor, szingularitás),
körív mentén az 1–9 kapuk,
belül spirálban elhelyezve a tökéletes számok pontjai,
és Bezier-görbékkel routolva a megfelelő kapukhoz (digital root alapján).
Függőségek
Python csomagok:
matplotlib
numpy
Telepítés:
pip install matplotlib numpy
Futtatás
python a_kerek_master.py
Eredmény:
Konzol: log + megerősítés
Fájl: ws501_routing_table.csv
Fájl: ws501_routed_mandala_final.png
---
🇩🇪 README (Deutsch)
Projektname: WS-501 · A_KEREK_MASTER – Routed Mandala
Autor: Balázs Maus (der „CSŐ“)
Kurzbeschreibung
Dieses Projekt speichert in einer einzigen Python-Datei ein zentrales Artefakt des WS-501-Systems:
die ersten 12 perfekten Zahlen
deren digitale Wurzel (digital root)
die Zuordnung zu den 1–9 AXIOM GATES
eine grafische Mandala-Visualisierung mit Bezier-Flows
sowie eine CSV-Routingtabelle als auditierbare Datenbasis.
Was macht der Code?
1. Digitale Wurzel:
Berechnet für jede perfekte Zahl die digitale Wurzel (1–9).
2. Gate-Zuordnung (1–9):
Die digitale Wurzel bestimmt, zu welchem Gate die Zahl gehört (UNIT, BRIDGE, ROOT, 4.VECTOR, BALÁZS, CORE, EXPLORE, OCTAVE, CLOSURE).
3. CSV-Export:
Schreibt ws501_routing_table.csv mit:
Wert, Anzahl der Ziffern, digital root, Gate, Gate-Name, Zeitstempel, Hash, Architekt.
4. Visualisierung (Mandala):
Erzeugt eine PNG-Datei ws501_routed_mandala_final.png:
Zentrum: 4.V (Singularität)
Kreis: 1–9 Gates
Innen: Punkte für perfekte Zahlen
Bezier-Kurven als Routing-Linien zum jeweiligen Gate.
Abhängigkeiten
Python-Pakete:
matplotlib
numpy
Installation:
pip install matplotlib numpy
Ausführung:
python a_kerek_master.py
---
🇬🇧 README (English)
Project name: WS-501 · A_KEREK_MASTER – Routed Mandala
Author: Balázs Maus (the „CSŐ“)
Short description
This project encodes, in one single Python file, a central WS-501 artefact:
the first 12 perfect numbers
their digital roots
a mapping to the 1–9 AXIOM GATES
a routed mandala visualization using Bezier curves
and a CSV routing table for auditing and reuse.
What the code does
1. Digital root computation
For each perfect number, it computes its digital root (1–9).
2. Gate mapping (1–9 Axiom Gates)
The digital root selects which gate the number belongs to: UNIT, BRIDGE, ROOT, 4.VECTOR, BALÁZS, CORE, EXPLORE, OCTAVE, CLOSURE.
3. CSV export
Generates ws501_routing_table.csv containing: index, perfect number, digit count, digital root, gate, gate name, architect, timestamp, hash.
4. Visualization (mandala)
Generates a PNG file ws501_routed_mandala_final.png:
center: 4.V (the singularity)
outer ring: gates 1–9
inner spiral: points for perfect numbers
quadratic Bezier curves: routes from each perfect number to its gate.
Dependencies
Python packages:
matplotlib
numpy
Install:
pip install matplotlib numpy
Run:
python a_kerek_master.py
---
2. Clean English Python code (single file, ready to run)
"""
WS-501 · A_KEREK_MASTER – Routed Mandala
Author: Balázs Maus
Final cleaned English version
Generates:
1) ws501_routing_table.csv – routing table for perfect numbers
2) ws501_routed_mandala_final.png – Bezier-flow mandala visualization
"""
import math
import os
import csv
from datetime import datetime
import matplotlib.pyplot as plt
import numpy as np
class AKerekMaster:
"""Single-point artifact: perfect numbers → 1–9 gates via digital roots."""
def __init__(self):
self.author = "Balázs Maus"
self.date = "2025-12-05"
self.pulse_bpm = 72.72727272727272
self.signature = 2266
# First 12 perfect numbers (as in the original artifact)
self.perfect_numbers = [
6,
28,
496,
8128,
33550336,
8589869056,
137438691328,
2305843008139952128,
2658455991569831744654692615953842176,
191561942608236107294793378084303638130997321548169216,
13164036458569648337239753460458722910223472318386943117783728128,
144740111546645244279463731260859884815736167124837727939109016905466971008000,
]
# Gate labels for DR = 1..9
self.gate_names = {
1: "UNIT",
2: "BRIDGE",
3: "ROOT",
4: "4.VECTOR",
5: "BALÁZS",
6: "CORE",
7: "EXPLORE",
8: "OCTAVE",
9: "CLOSURE",
}
# Colors for gates 1..9
self.gate_colors = {
1: " ",
2: " ",
3: " ",
4: " ",
5: " ",
6: " ",
7: " ",
8: " ",
9: " ",
}
def digital_root(n: int) -> int:
"""Compute the digital root in [1..9] (0 only if n == 0)."""
if n == 0:
return 0
return 1 + (n - 1) % 9
def _quad_bezier(
ax,
p0,
p1,
p2,
color: str,
lw: float = 2.4,
alpha: float = 0.5,
steps: int = 120,
) -> None:
"""Draw a quadratic Bezier curve from p0 to p2 with control point p1."""
t = np.linspace(0.0, 1.0, steps)
x = (1 - t) ** 2 * p0[0] + 2 * (1 - t) * t * p1[0] + t**2 * p2[0]
y = (1 - t) ** 2 * p0[1] + 2 * (1 - t) * t * p1[1] + t**2 * p2[1]
ax.plot(x, y, "-", color=color, lw=lw, alpha=alpha, zorder=1)
# ------------------------------------------------------------------
# 1) Data export: routing table
# ------------------------------------------------------------------
def export_routing_table(self, filename: str = "ws501_routing_table.csv") -> None:
"""Export a CSV routing table: perfect number → digital root → gate."""
print(f"[WS-501] Building routing table: {filename}")
rows = []
for index, value in enumerate(self.perfect_numbers, start=1):
dr = self.digital_root(value)
digits = len(str(value))
gate = dr
gate_name = self.gate_names[dr]
rows.append(
{
"index": index,
"perfect_number": value,
"digits": digits,
"digital_root": dr,
"gate": gate,
"gate_name": gate_name,
"architect": self.author,
"timestamp": datetime.now().isoformat(),
"hash": "FF006E99",
}
)
with open(filename, "w", newline="", encoding="utf-8") as f:
writer = csv.DictWriter(f, fieldnames=rows[0].keys())
writer.writeheader()
writer.writerows(rows)
print(f"[WS-501] Routing table saved at: {os.path.abspath(filename)}")
# ------------------------------------------------------------------
# 2) Visualization: mandala with Bezier routing
# ------------------------------------------------------------------
def draw_mandala(self, filename: str = "ws501_routed_mandala_final.png") -> None:
"""Generate the routed mandala visualization and save it as PNG."""
print("[WS-501] Generating mandala visualization...")
fig = plt.figure(figsize=(28, 28))
ax = plt.gca()
ax.set_facecolor("black")
ax.set_xlim(-1.4, 1.4)
ax.set_ylim(-1.4, 1.4)
plt.axis("off")
# Main circle (the field)
outer_circle = plt.Circle(
(0, 0),
1.0,
color=" ",
alpha=0.15,
lw=12,
ec=" ",
)
ax.add_patch(outer_circle)
# Center: 4.V (4th vector / singularity)
plt.plot(
0,
0,
"o",
markersize=110,
markerfacecolor="black",
markeredgecolor=" ",
markeredgewidth=10,
zorder=30,
)
plt.text(
0,
0,
"4.V",
fontsize=80,
ha="center",
va="center",
color=" ",
weight="bold",
zorder=31,
)
# Gate ring: 1–9
radius_gate = 0.86
for k in range(1, 10):
angle_deg = 90 - (k - 1) * 40
angle_rad = math.radians(angle_deg)
x = radius_gate * math.cos(angle_rad)
y = radius_gate * math.sin(angle_rad)
color = self.gate_colors[k]
label = self.gate_names[k]
plt.plot(
x,
y,
"o",
markersize=55,
color=color,
mec="white",
mew=5,
zorder=20,
)
plt.text(
x,
y,
str(k),
fontsize=36,
ha="center",
va="center",
color="black",
weight="bold",
)
plt.text(
x,
y - 0.10,
label,
fontsize=16,
ha="center",
color=color,
weight="bold",
)
# Glow for 3–6–9 backbone
for k in (3, 6, 9):
angle_deg = 90 - (k - 1) * 40
angle_rad = math.radians(angle_deg)
gx = radius_gate * math.cos(angle_rad)
gy = radius_gate * math.sin(angle_rad)
plt.plot(
gx,
gy,
"o",
markersize=90,
color=self.gate_colors[k],
alpha=0.25,
zorder=0,
)
# DR-routing: perfect numbers → gate via Bezier curves
for i, value in enumerate(self.perfect_numbers):
dr = self.digital_root(value)
depth = len(str(value))
# Radius chosen based on digit length
radius = 0.20 + (depth * 0.019)
# Angle along a golden-angle spiral
angle_rad = math.radians(i * 137.508)
px = radius * math.cos(angle_rad)
py = radius * math.sin(angle_rad)
# Target gate position based on DR
gate_angle_deg = 90 - (dr - 1) * 40
gate_angle_rad = math.radians(gate_angle_deg)
gx = radius_gate * math.cos(gate_angle_rad)
gy = radius_gate * math.sin(gate_angle_rad)
# Control point pulls curve toward the center a bit
cx = px * 0.5
cy = py * 0.5
self._quad_bezier(
ax,
(px, py),
(cx, cy),
(gx, gy),
color=self.gate_colors[dr],
)
# Mark the perfect number point
plt.plot(px, py, ".", markersize=10, color="white", alpha=0.9, zorder=2)
plt.text(
px,
py - 0.035,
f"DR:{dr}",
fontsize=9,
color=" ",
family="monospace",
ha="center",
)
# Signature node at gate 5 (BALÁZS)
gate5_angle_deg = 90 - 4 * 40 # k = 5
gate5_angle_rad = math.radians(gate5_angle_deg)
sx = radius_gate * math.cos(gate5_angle_rad)
sy = radius_gate * math.sin(gate5_angle_rad)
plt.plot(
sx,
sy,
"o",
markersize=70,
color="white",
mec=" ",
mew=8,
zorder=25,
)
plt.text(
sx,
sy,
str(self.signature),
fontsize=20,
ha="center",
va="center",
color=" ",
weight="bold",
)
# Pulse & meta text
plt.text(
0,
0.98,
f"PULSE: {self.pulse_bpm:.15f} BPM",
fontsize=24,
ha="center",
color=" ",
weight="bold",
)
plt.text(
0,
0.90,
"ATLAS → 3i → 2i → i",
fontsize=20,
ha="center",
color=" ",
)
# Footer
plt.text(
0,
-1.00,
f"ARCHITECT: {self.author}",
fontsize=22,
ha="center",
color=" ",
family="monospace",
)
plt.text(
0,
-1.10,
f"{self.date} · WS-501 · v5.0 · FINAL",
fontsize=16,
ha="center",
color=" #666666",
family="monospace",
)
plt.title(
"A KEREK – DR-ROUTING BEZIER FLOW\nThe single point that contains everything",
fontsize=36,
color=" ",
pad=70,
weight="bold",
)
# Save PNG
plt.savefig(filename, dpi=600, facecolor="black", bbox_inches="tight")
print(f"[WS-501] Mandala image saved at: {os.path.abspath(filename)}")
plt.show()
# ------------------------------------------------------------------
# Public entry point
# ------------------------------------------------------------------
def run(self) -> None:
print("=" * 90)
print("WS-501 · A_KEREK_MASTER – FINAL ARTIFACT")
print("Perfect numbers → digital roots → 1–9 gates (data + image).")
print(f"Architect: {self.author} | Hash: FF006E99")
print("=" * 90)
self.export_routing_table()
self.draw_mandala()
if __name__ == "__main__":
AKerekMaster().run()
---
3. „Vegytiszta” APL – core routing logic
Ez a rész a mag logikát viszi át APL-be:
tökéletes számok vektora
digital root függvény
gate-nevek hozzárendelése
routing tábla előállítása (kiírható CSV-be)
Példa Dyalog APL szintaxissal:
⍝ WS-501 · A_KEREK_MASTER – Core Routing in pure APL
⍝ 1) Perfect numbers (first 12)
perfect ← 6 28 496 8128 33550336 8589869056
perfect ,← 137438691328 2305843008139952128
perfect ,← 2658455991569831744654692615953842176
perfect ,← 191561942608236107294793378084303638130997321548169216
perfect ,← 13164036458569648337239753460458722910223472318386943117783728128
perfect ,← 144740111546645244279463731260859884815736167124837727939109016905466971008000
⍝ 2) Digital root function
dr ← {
⍝ digital root in 1..9 (0 only if argument is 0)
0=⍵:0
1+9|⍵-1
}
⍝ 3) Gate names (1..9)
gateNames ← 'UNIT' 'BRIDGE' 'ROOT' '4.VECTOR' 'BALAZS' 'CORE' 'EXPLORE' 'OCTAVE' 'CLOSURE'
⍝ 4) Routing row for a single perfect number
makeRow ← {
p ← ⍵
droot ← dr p
digits ← ≢⍕p ⍝ number of digits
gate ← droot
name ← gateNames[droot]
(p digits droot gate name)
}
⍝ 5) Full routing table (nested vector of rows)
routingTable ← makeRow¨ perfect
⍝ 6) Optional: show nicely
⍝ Each row: perfect, digits, digitalRoot, gate, gateName
routingTable
Ha CSV-t akarsz APL-ből:
⍝ Very simple CSV writer (text-only, no quoting)
toCSVRow ← {
p digits droot gate name ← ⍵
(⍕p),',',⍕digits,',',⍕droot,',',⍕gate,',',name
}
csvLines ← 'perfect_number,digits,digital_root,gate,gate_name' ,⍪ toCSVRow¨ routingTable
⍝ Write to file (Dyalog APL)
⎕NPUT 'ws501_routing_table_apl.csv' csvLines
---
