NYA-9: Building a Physics-Inspired Hash Function from 4D Space

Michael Kissi-Mensah — Thu, 28 May 2026 20:13:39 +0000

_What happens when you replace bit-shuffling with hyperbolic lattices, gyroscopic tuning, and pressure fields? A deep-dive into the Lynchpin Physics Engine powering NYA-9.
_

Most hash functions are built on one idea: mathematical chaos through algebra. XOR, bit rotation, modular addition — repeated until the output looks random. SHA-256 uses exactly this approach, and it works extraordinarily well.

NYA-9 (Not Your Address) takes a fundamentally different route. Instead of algebraic mixing, it simulates a miniature physical universe — a four-dimensional hyperbolic lattice, gyroscopic incidence angles, and pressure fields — and uses the unpredictable geometry of that universe as its diffusion engine.

This post breaks down every physics concept inside NYA-9's Lynchpin Physics Engine: what it is, why it creates diffusion, and how it maps to the code.

The Core Idea: Physics as a Pseudorandom Oracle
A hash function needs two things above all: diffusion (every output bit depends on every input bit) and confusion (the relationship between key and ciphertext is obscured). Traditional designs achieve this with carefully chosen linear algebra over finite fields.

NYA-9 achieves it differently: by encoding message data into the parameters of a physical simulation, running that simulation, and extracting geometric quantities (energies, angles, Lynchpin products) as the mixed state. The claim is that the sensitivity of chaotic physical systems — small changes in initial conditions produce wildly different trajectories — acts as a natural diffusion mechanism.

The Lynchpin Physics Engine is not a physics simulator in the traditional sense. It is a deterministic mathematical model inspired by physical concepts, designed to produce geometrically complex, high-entropy transformations on floating-point state vectors.

Layer 1 — The Hyperbolic Pentagonal 4D Lattice
Geometry · Topology
The structural backbone of NYA-9 is a HyperbolicPentagonalLattice4D — a tiling of four-dimensional hyperbolic space using pentagonal faces.

What is hyperbolic space?
Euclidean space is flat: the angles of a triangle sum to exactly 180°, and parallel lines never meet. Hyperbolic space is negatively curved: triangles have angles summing to less than 180°, and the space "expands" faster than Euclidean space as you move outward.

The key consequence for our purposes is exponential volume growth. In Euclidean 3D space, a ball of radius r has volume proportional to r³. In hyperbolic space, it grows exponentially with r. This means a small perturbation propagates to an exponentially larger set of nearby points.

Curvature comparison
K = 0
Euclidean (flat)
Parallel lines stay parallel. Triangle angles = 180°. Volume ∝ r³
K > 0
Spherical (positive)
Parallel lines converge. Triangle angles > 180°. Think: globe surface
K < 0
Hyperbolic (negative)
Parallel lines diverge. Triangle angles < 180°. Volume grows exponentially
Why pentagonal tiling?
In the Euclidean plane, you can tile with triangles, squares, or hexagons. In hyperbolic space, pentagons tile naturally at the {5, 4} Schläfli symbol — four pentagons meet at each vertex. This is impossible in flat geometry (four pentagons at a vertex would leave a gap), but the negative curvature provides exactly the right "extra space."

Extending this to four dimensions, the HyperbolicPentagonalLattice4D builds a lattice of 4D nodes arranged according to hyperbolic tiling rules. The lattice is grown recursively to a specified depth from an initial_radius, with each layer of nodes exponentially farther from center in the embedding.

Why does this matter for hashing?
The lattice structure means that nearby message seeds, once encoded into the lattice geometry, project to very different configurations in 3D (via project_4d_to_3d()). The exponential divergence property of hyperbolic space is doing the cryptographic work of ensuring that similar inputs produce dissimilar geometric states.

Layer 2 — 4D → 3D Projection
Dimensional Reduction
The lattice lives in 4D, but the physics computations (pressure, incidence) operate in 3D. The TetryenGeometry class handles this via project_4d_to_3d().

The classical analogue is the projection of a 3D object onto a 2D surface. Think of a shadow: the same 3D object casts different shadows depending on the angle of light. Projecting from 4D to 3D has a similar property — the same 4D structure looks different from every 3D "viewpoint."

For a 4D point p = (x, y, z, w):
Stereographic projection: (x,y,z) → (x/(1-w), y/(1-w), z/(1-w))
Orthographic projection: (x,y,z) → (x, y, z) [drop w]

NYA-9 uses a physics-engine-specific projection
that incorporates the lattice topology into the map.
In each round of _physics_mix, the current state vector modulates the projected node positions:

nodes_modified = nodes + (state[:3] * message_seed) * mod_scale * cos(phase)
This is the message injection step. The incoming state (derived from the message) physically displaces the lattice nodes before physics quantities are computed on them. Every message therefore produces a unique geometric configuration.

Layer 3 — The Pressure Field
Field Theory · Energy Functionals
With the lattice projected into 3D, the PressureField class computes a pressure functional over the node positions. This is a scalar value — a single floating-point number — encoding the "energetic state" of the configuration.

What is a pressure functional?
In physics, a functional maps a field configuration to a number (think: "total energy of this arrangement of particles"). Pressure functionals specifically encode how compressed or expanded a distribution of points is — analogous to the thermodynamic pressure of a gas.

The HowardComma class provides the arithmetic basis for the pressure computation. The "comma" in just intonation theory refers to small pitch intervals that arise from the difference between acoustically pure intervals — a metaphor for the small but nonzero deviations in the lattice that drive the energy computation.

The pressure functional is sensitive to the arrangement of nodes, not just their individual positions. Moving any single node changes the computed energy for the entire system — this is the source of NYA-9's avalanche-like behavior.

Why a pressure field?
Pressure fields have a useful property for hash design: they are global functions of the configuration. A small perturbation in one corner of the lattice propagates through the pressure calculation to affect the single output scalar energy. This is diffusion achieved through a physical law, not an algebraic schedule.

Layer 4 — Gyroscopic Incidence Dynamics
Classical Mechanics · Rotational Physics
The second major physics primitive is IncidenceDynamics, built on top of the RussellOctave class. This computes meeting angles between lattice nodes and applies gyroscopic tuning to the state.

Gyroscopic motion
A gyroscope resists changes to its orientation due to the conservation of angular momentum. When a torque is applied, instead of tipping over, a gyroscope precesses — it rotates around a secondary axis perpendicular to the applied force. The key formula is:

Precession rate Ω = τ / L

where τ = applied torque
L = angular momentum (= I · ω)
I = moment of inertia
ω = spin angular velocity
In NYA-9, RussellOctave.gyroscopic_tuning(r) computes a tuning factor for round r. The "Russell Octave" is a harmonic reference frame — each round index maps to a harmonic partial in an octave series, and the gyroscopic tuning value scales the state mixing at that round. This creates a frequency-domain schedule for the round-by-round diffusion: early rounds have different mixing weights than late rounds, mimicking the way a gyroscope's precession rate depends on its spin frequency.

Incidence angles
compute_meeting_angle(node_a, node_b, radial=True) computes the angle between two lattice nodes relative to the radial direction from origin. This is the "incidence angle" — the angle at which two geometric entities meet a reference surface.

In optics, the incidence angle determines reflection and refraction. Here, it determines how the pressure energy and the geometric configuration interact in the Lynchpin multiplication step. Different message seeds produce different projected node positions, hence different incidence angles, hence different final hash states.

Layer 5 — Lynchpin Arithmetic
Novel Arithmetic
At the core of every round is LynchpinArithmetic.lynchpin_mult(a, b) — a custom multiplication operation parameterized by the lattice constant R = 2.29e-10 (on the order of an atomic radius in meters).

This is not ordinary floating-point multiplication. The Lynchpin product incorporates R as a scaling parameter, creating a non-standard algebraic structure where the product of two values depends on a physical constant. The effect is that the arithmetic is unit-aware — values near the atomic scale mix differently than macroscopic values, creating additional nonlinearity in the state evolution.

Lynchpin product (schematic):
L(a, b) = f(a * b, R)

where f encodes a physics-engine-specific
nonlinear combination of the product with R,
ensuring scale-sensitive mixing.
The two Lynchpin products computed per round are:

l1 = L(energy * 0.12, angle * 0.6)
l2 = L(state[0], energy * message_seed * 0.08)

lynch_val = l1 * 0.7 + l2 * 0.3
This blends the pressure energy and incidence angle (geometric quantities) with the current state and message seed (input-derived quantities), producing a single mixed scalar per round.

The Full Round Function
Putting it all together, each of the 9 rounds of NYA-9 executes the following pipeline:

State vector (6D)
→
Modulate lattice nodes
→
Project 4D → 3D
→
Compute pressure energy
→
Compute incidence angle
→
Lynchpin multiply
→
New state vector
After the final round, the state is encoded as bytes and passed through a final SHA-256 call, which provides cryptographic finalization — ensuring the output is uniformly distributed even if the physics layer has any residual structure.

Output size
256 bits
32-byte hex digest
Rounds
9
Configurable at init
State dimensions
6D float64
Per round
Lattice depth
3
Hyperbolic layers
Lattice constant R
2.29×10⁻¹⁰
~Bohr radius scale
Finalization
SHA-256
On physics state bytes
A Note on Cryptographic Security
NYA-9 is a fascinating construction, and the physics-inspired diffusion is genuinely novel. However, it is important to be clear: NYA-9 has not been cryptanalyzed, and its security properties are not formally proven.

The final SHA-256 step ensures that the output is at least as strong as SHA-256 itself — but it also means the physics layer's security properties do not strictly need to hold for the digest to be secure. The Lynchpin Engine contributes entropy and complexity; the SHA-256 finalizer provides the formal security guarantee.

For production use, stick to NIST-standardized functions (SHA-256, SHA-3). NYA-9 is best understood as a research vehicle for exploring physical systems as pseudorandom oracles — and as a creative demonstration that cryptographic primitives can be designed from very different first principles.

Summary
NYA-9's Lynchpin Physics Engine layers five distinct physical and mathematical concepts to achieve diffusion:

01
Hyperbolic 4D Lattice
Exponential volume growth ensures similar inputs diverge geometrically
02
4D → 3D Projection
Message state modulates node positions before physics evaluation
03
Pressure Functional
Global energy encodes full configuration; any change propagates everywhere
04
Gyroscopic Incidence
Angular momentum metaphor schedules per-round mixing weights
05
Lynchpin Arithmetic
Scale-sensitive multiplication combines geometric and message quantities
What makes NYA-9 conceptually compelling is not whether it is more secure than SHA-256 — it almost certainly isn't, for now — but that it demonstrates a completely different philosophy: physics as a diffusion engine, geometry as a mixing layer, and space itself as the source of randomness.

If you are building your own experimental hash function, these are the primitives worth stealing: hyperbolic geometry for exponential divergence, pressure fields for global sensitivity, and gyroscopic schedules for frequency-domain mixing.

DEV Community: Michael Kissi-Mensah

NYA-9: Building a Physics-Inspired Hash Function from 4D Space