When two identities meet through an actor, a third identity is born. That birth is z.
Time is z becoming the next x.
Plainly
Pages 1, 2, and 3 named the pieces. This page is what
happens when those pieces are put together.
Take two identities — x and
y. Apply an actor to them, say
×. Something new comes out. We call
that something z. It is not a number,
even when it looks like one. z is itself an
identity — the identity that the act has just
manifested into the world.
And that newborn identity does not just sit there. It
becomes the next x. Another y meets it,
another act fires, another z emerges. That repeating
step — z becoming the next x — is what
Dimensional Programming calls time.
Time is not a clock ticking. Time is identity recurring.
The whole landscape of every possible (x, y) pair under
a given actor is called the manifold.
The manifold is never stored. It is queried, point by
point, only at the (x, y) the system actually visits.
Nothing in between is computed. Nothing in between
exists until asked.
Sharper
Manifestation:z = op(x, y). z is a first-class identity, not a value
or a state cache.
Recursion law:x_{n+1} = z_n. The output of one step is the input of
the next. There is no recursion within a dimension; recursion is always from one manifested
z back into x at the same or adjacent dimension.
Manifold law: the surface { (x, y, z) : z = op(x, y) } is geometric,
not material. It is queried at the points the system traverses; it is never enumerated, indexed, or
stored.
Time: the trajectory of x through the recursion is what observers experience as
time. Time has no separate variable.
z is born from (x, y, op) and immediately becomes the next x. Time is not a variable; it is this
loop.
The same surface, many lenses
Because the manifold is geometric and identity-blind,
the surface z = x · y is the same surface
whether the identities are colours, sounds, frames, or
game-states. A "lens" is a chosen interpretation of
what x, y, and z name in a given domain. The
geometry is invariant; only the names rotate.
Domain
x
y
z = x · y
Numbers
3
4
12
Geometry
length
width
area (one dim up)
Colour
hue
luminance
rendered shade
Sound
pitch
amplitude
perceived tone
Harmonics
fundamental
partial
chord identity
What this rules out
State stores that hold z independently of (x, y). Caches
of "the manifold" as a precomputed table. Recursion that
runs inside a single dimension instead of
stepping through it. Code that treats time as a separate
clock variable rather than as the recursion of identity.
Each is a violation of the manifestation law.
See it live
The companion page /x-dimensional/saddle/
renders the multiplicative manifold z = x · y
in 3D and walks system identities along it. Each frame
re-queries z from (x, y); the trail is not stored; the
head's z is provably on the surface. Watch the
paradigm execute.