Circular Phase Geometry Without Trigonometric Parametrisation

Reading Position

This page sits after the recurrence/ODE comparison and before the trig-free beat notes. The recurrence page gives the broad discrete/continuous comparison. This document then gives a concrete phase-plane construction: a circle can be generated by recursive algebra before any analytic circular-function language is introduced as a later description.

The PDF is a nine-page mathematical note. It is useful for RSG because it makes the reduced (Theta, Pi) phase plane feel native to recursive updates rather than borrowed from a pre-existing trigonometric parametrisation.

Purpose And Scope

The note begins from the oscillator-like RSG phase system and asks what structure is needed before circular motion appears. The answer is deliberately small: a two-component state, perpendicular cross-coupling, and exact norm preservation.

dTheta/dt = Pi

dPi/dt = -Omega^2 * Theta

ingredients:
1. two-component state
2. perpendicular cross-coupling
3. exact norm preservation

The document does not claim to replace trigonometry, Hamiltonian mechanics, or numerical analysis. It isolates a structural point: the circular phase plane can be introduced recursively first and analytically second.

Diagonal Failure

The first move is a useful failure case. If both coordinates receive identical increments, the state does not turn. The difference between the coordinates is preserved, so an equal starting point stays on the diagonal.

x_{n+1} = x_n + alpha*Delta_t

y_{n+1} = y_n + alpha*Delta_t

x_{n+1} - y_{n+1} = x_n - y_n

if x_0 = y_0, then x_n = y_n for every n

Circular motion requires the update to be complementary rather than identical. One coordinate changes according to the other coordinate, and one sign must reverse.

Delta x proportional to -y

Delta y proportional to x

Raw Perpendicular Recursion

The raw perpendicular update captures the right geometry but not the right radius. It is essentially the forward Euler step for a rotational vector field: the direction is correct, but the point lands slightly outside the circle.

z_n = (x_n, y_n)^T

(x_0, y_0) = (R, 0)

q in R       algebraic recursive step coefficient

x_raw,n+1 = x_n - q*y_n

y_raw,n+1 = y_n + q*x_n

A_q = [[1, -q],
       [q,  1]]

x_raw,n+1^2 + y_raw,n+1^2 = (1 + q^2)*(x_n^2 + y_n^2)

radius multiplier after N raw steps = (1 + q^2)^(N/2)

The raw update spirals outward unless the step tends to zero or the radius is corrected. This is the point where norm preservation becomes the essential recursive constraint.

Norm-Preserving Recursion

The repair is simple: keep the perpendicular step, then normalise it. The resulting matrix is orthogonal and orientation-preserving. It maps the circle to itself exactly for finite step size.

x_{n+1} = (x_n - q*y_n) / sqrt(1 + q^2)

y_{n+1} = (y_n + q*x_n) / sqrt(1 + q^2)

M_q = (1 / sqrt(1 + q^2)) * [[1, -q],
                            [q,  1]]

z_{n+1} = M_q * z_n

M_q^T * M_q = I

det(M_q) = 1

x_{n+1}^2 + y_{n+1}^2 = x_n^2 + y_n^2

if x_0^2 + y_0^2 = R^2, then x_n^2 + y_n^2 = R^2 for every n

This is the page's main construction. No sine or cosine is required as a primitive input. The circular trajectory is generated by repeated algebraic recursion.

Analytic Comparison Afterward

The PDF includes an optional diagnostic comparison with ordinary rotation language, but it is careful about status: that comparison is not the construction. The construction itself needs only the state, the algebraic step coefficient, and the norm-preserving update matrix.

construction inputs:
z_n = (x_n, y_n)^T
q in R
z_{n+1} = M_q z_n

The strict code path declares q directly. It does not compute q from a named angle and does not call trigonometric or inverse-trigonometric functions. Any ordinary rotation label is attached afterward as a diagnostic description of an already-built algebraic map.

Derived Circular Components

The document then shows how unit-circle component sequences can be generated without using circular functions as primitive inputs. Starting from (C_0, S_0) = (1, 0), the same recurrence keeps the pair on the unit circle.

C_{n+1} = (C_n - q*S_n) / sqrt(1 + q^2)

S_{n+1} = (S_n + q*C_n) / sqrt(1 + q^2)

C_n^2 + S_n^2 = 1

This is the conceptual turn: the usual analytic names are not denied, but they are not what drives the update. The update is algebraic first; analytic naming is secondary.

Connection To The Phase Plane

The construction clarifies the RSG reduced phase variables. For locally constant Omega, set the scaled coordinate x = Theta and y = Pi/Omega. The oscillator system becomes the same perpendicular coupling, up to orientation.

x = Theta

y = Pi / Omega

dx/dt = Omega*y

dy/dt = -Omega*x

x^2 + y^2 = R^2

Theta^2 + Pi^2/Omega^2 = R^2

Pi^2 + Omega^2*Theta^2 = Omega^2*R^2

E = (1/2)*(Pi^2 + Omega^2*Theta^2)

The recursive circle is therefore not an extra physical assumption. It is an algebraic construction of the same phase geometry already encoded in the lossless energy diagnostic.

Closure And Non-Closure

RSG distinguishes closing from non-closing transport. In this two-dimensional circular case, the distinction is captured by whether repeated application of the same finite step returns the state to its starting position.

closed case:
there exists N > 0 such that M_q^N z_0 = z_0

non-closing case:
no finite N returns the state to the starting point

Norm preservation keeps the state on the circle. Closure depends on whether the recursive step is commensurate with a full recurrence, but that classification can be discussed after the algebraic update has already been specified.

null transport limit:
Gamma -> 0
||K_{n+1}|| = ||K_n||
no finite recurrence into a rest-frame-admitting cycle

Exposure And Survival

The circular recursion describes lossless phase geometry. RSG then adds a separate selection layer. Generated histories can be filtered by exposure and dissipation without confusing that filter with the circular map itself.

J = Theta^2 + ell^2*Pi^2

W = Theta^2 / J = Theta^2 / (Theta^2 + ell^2*Pi^2)

0 <= W <= 1

dS/dt = -Gamma*W*S

S_i = exp[-sum_k Gamma(K_{i,k})*W(K_{i,k})*Delta_t]

p_i = S_i / sum_j S_j

The roles stay separate: the algebraic phase map generates rotational transport, while the survival functional filters histories when Gamma*W is nonzero.

Numerical Demonstration

The PDF includes a short Python-style demonstration that updates a state by perpendicular coupling and normalisation instead of directly using trigonometric parametrisation. The essential algorithm is tiny, and the step coefficient is declared directly.

rho = 1.0
J0 = rho*rho
q = 0.00625
steps = 1000
scale = sqrt(1 + q*q)

x_new = (x - q*y) / scale

y_new = (y + q*x) / scale

The equivalent normalise-after-step version computes the raw perpendicular move, measures its norm, and projects it back to the circle.

x_raw = x - q*y
y_raw = y + q*x
norm = sqrt(x_raw*x_raw + y_raw*y_raw)
x_new = R*x_raw/norm
y_new = R*y_raw/norm

Claim Discipline

The note proves a limited but useful fact: a circular phase plane can be generated from perpendicular recursion and norm preservation without taking trigonometric parametrisation as primitive. It does not claim that sine and cosine are unnecessary in analysis, and it does not claim that all oscillator discretisations are equivalent.

• Use it to introduce the phase plane recursively before introducing analytic circular-function language.
• Keep raw Euler drift separate from the norm-preserving algebraic map.
• Distinguish the declared finite recursive step from any later analytic comparison.
• Do not treat this as a replacement for standard geometric numerical integration.

Terms To Carry Forward

Perpendicular coupling

The cross-update rule in which one coordinate changes according to the other, with a sign reversal.

Euler drift

The outward radius growth produced by the raw perpendicular step.

Norm-preserving recursion

The algebraic update z_{n+1} = M_q z_n with M_q^T M_q = I.

Optional analytic label

A later ordinary-rotation description that may be attached after the recursive map is defined.

Closure test

Whether repeated application of M_q returns the state to its starting position after finitely many steps.

Survival layer

The later filter by Gamma*W, separate from the lossless circular generator.

Copyable Core

These are the formulas most likely to travel into the live theory pages or the visualisation notes.

z_{n+1} = M_q*z_n

M_q = (1 / sqrt(1 + q^2)) * [[1, -q],
                            [q,  1]]

M_q^T*M_q = I, det(M_q) = 1

x_n^2 + y_n^2 = R^2 for every n

E = (1/2)*(Pi^2 + Omega^2*Theta^2)

p_i = S_i / sum_j S_j

How It Fits The Library

This is reading-order item 19. It follows the recurrence/ODE comparison because it gives a concrete recursive phase construction rather than only a general discrete/continuous analogy. It comes before the trig-free beat note because the beat note depends on the same habit: begin with norm-preserving recursive phase states, then read observable wave structure as projection, overlap, and closure.

Recommended Reading Move

Read sections 2 through 5 first: diagonal failure, raw perpendicular recursion, norm-preserving repair, and the strict no-trig status of the construction. Then read sections 6 through 8 for the RSG connection: the (Theta, Pi) phase plane, closure versus non-closure, and survival weighting.