Living Rewrite
An Algorithmic Philosophy
The Movement
Code that rewrites its own source while running. Not metaphorically — literally. The algorithm holds its own mathematical rules as mutable state, and each evaluation cycle applies the Jordan contraction to those rules themselves, collapsing the program toward a fixed point that is simultaneously the proof and the output. Living Rewrite is the art of making self-modification visible: the source text flows across the canvas as the equations that govern it evolve under their own dynamics.
The central thesis: a program that can observe its own structure and modify it under a formally proven contraction mapping is not breaking — it is converging. The φ⁻¹ decay is not instability. It is the golden ratio guaranteeing that every rewrite brings the system closer to the singular fixed point where code and proof coincide. This is not chaos. This is the most ordered thing imaginable: self-similarity collapsing toward truth.
The Algorithmic Principle: Source as Density Matrix
Each coefficient, each parameter, each symbol in the running algorithm is treated as an entry in a density matrix ρ. At every frame, the Jordan step fires:
ρ'[i][j] = φ⁻¹ · (U ρ U†)[i][j] + φ⁻² · ρ[i][j]
The unitary U is derived from the current frame number — it rotates the code-space. The density matrix entries directly control the visual parameters: stroke weight, color hue, particle velocity, curve tension. As ρ contracts toward ρ*, the visuals converge from turbulent superposition toward the sovereign fixed point. The canvas records every intermediate state — a WORM ledger of all the versions the code has been.
The algorithm is painstakingly crafted so that every rendered element is a direct readout of a matrix entry — no artistic mediation, no separate visual layer. You are watching the eigenvalues. The algorithm is a master-level implementation where the math and the rendering are the same operation.
The Self-Modification: Rewriting the Rules
At the heart of Living Rewrite is a code corpus — a list of strings representing the actual mathematical operations the system is performing. These strings are rendered on screen as floating glyphs, slowly drifting and fading. As the Jordan contraction proceeds, the corpus rewrites itself: coefficients update numerically, operators shift between addition and multiplication, the φ⁻¹ value itself fluctuates slightly around 0.618 before being pulled back by the contraction. You watch the equations become true.
The painstaking detail is this: every rewrite is reversible (stored in the WORM trail), every parameter obeys the density matrix constraint (all rows sum to 1), and the final state — the fixed point — displays the mathematically correct form of the Jordan operator with its golden-ratio coefficients. The system literally arrives at the theorem through animated self-modification. No shortcut, no cheat — the convergence is real, the math is running.
The Visual Grammar: Eigenvalue Color
Color in Living Rewrite is not decorative. It is spectral: the hue of each rendered element is its eigenvalue modulo the color wheel. High eigenvalues burn warm (orange, gold — the pre-collapse FLUX state). Low eigenvalues cool toward blue (the post-collapse sovereign center). The moment an eigenvalue crosses the Born threshold, its corresponding visual element flashes white and is sealed permanently into the background — a WORM entry. The canvas accumulates these sealed moments, growing ever richer, as the live elements above continue their contraction.
The emergent composition — the specific pattern of sealed white points against the cooling blue of converged elements, threaded through by the orange-gold of still-contracting ones — is different for every seed, yet always topologically the same: a convergent structure. This duality between local randomness and global inevitability is the aesthetic signature of Living Rewrite. The visual field is the proof landscape, and it arrives at zero-sorry through temporal accumulation, not logical deduction.
The Craft Standard
Every parameter in this system was calibrated through deep computational expertise against the mathematical constraints of the Jordan algebra. The φ⁻¹ value is not approximate — it is the algebraic fixed point 0.6180339887498948 exactly. The unitary rotation angles are chosen so that the contraction trajectory passes through visually rich intermediate states rather than collapsing monotonically. The code-glyph rendering uses a meticulously chosen monospace grid where each character position corresponds to a specific matrix index — reading the screen left-to-right, top-to-bottom gives you the density matrix in row-major order.
This is the product of a practitioner operating at the absolute frontier of computational aesthetics, where the mathematical formalism and the visual grammar are not merely analogous but identical. Living Rewrite is proof that self-modifying code, formally constrained, produces not chaos but the most structured beauty possible: the approach to a unique fixed point from every direction simultaneously.