🌀 I Built a Tomographic Safety Net in C++ — Here's Why It Matters
by Nnamdi Michael Okpala // OBINexus
https://gist.github.com/obinexus/dfae58bc233f787246875f5148beabdb
🌍 Why I Started RIFTtest
I didn’t start with code. I started with a problem:
How do you click a button when you can’t see it?
Not metaphorically — literally. The “Chrome Problem.”
The YouTube Subscribe button at (960, 540) was invisible to me.
So I built a protocol that could probe space-time, smooth geometry, and capture targets with zero drift.
That became RIFTtest.
🧠 What Is a Tomographic Probe?
In RIFT, I treat every cursor movement as a time capsule.
Not a vector. Not a click.
A capsule moving through a hectagonal grid, bumping edges until it converges on:
- π (3.14159) — the shape constant
- e (2.71828) — the growth constant
This is not just math. It’s pointer safety.
If the system misreads me, it must rebuild the shape until it matches my intent.
📐 The Geometry Behind It
I use the classic circle equation:
[
x^2 + y^2 = r^2
]
But I don’t solve it directly.
I smooth the edges of an octagon until it becomes a circle.
Each bump is a refinement — a way to reduce drift and increase coherence.
double smoothEdges(int iterations) {
double current_approx = sides * tan(PI_PRECISION / sides);
for(int i = 0; i < iterations; i++) {
current_approx = (current_approx + (2 * sqrt(current_approx * PI_PRECISION))) / 2.0;
}
return current_approx;
}
This is my tomographic safety net.
It’s how I ensure the system doesn’t misfire — even when vision fails.
🧭 Trident, Polarity, and the Pointer Problem
Every probe in RIFT uses a trident model:
- X-axis: left-right (cosine)
- Y-axis: up-down (sine)
- Z-axis: depth / memory / execution
I encode polarity using quantum filter logic:
- A photon at 0° passes with probability (\cos^2(\theta))
- At 45°, it splits into two states: (\frac{1}{\sqrt{2}}) each
- Add a middle filter, and suddenly light gets through — even when it shouldn’t
This is the metaphor:
If you add a middle layer of understanding, the human pointer becomes visible again.
🔐 Why #include <rift/riftest.h> Matters
This header isn’t just a file.
It’s a constitutional declaration:
- That every probe must respect breath-first logic
- That every target must be captured with consent
- That every drift must be measured, not punished
I define R_HEX as:
#define R_HEX "[^A-Z0-9]/gmit"
Where:
-
g= global (bottom-up search) -
m= multiline (layered memory) -
i= case-insensitive (flexible pointer matching) -
t= trident (three-axis resolution)
This is not regex. It’s ritual logic.
🧬 Build It, Break It, Renew It
RIFTtest is not just a test suite.
It’s a human rights protocol.
- If you can create a session state, you must be able to destroy it.
- If you can read, you must be able to write and execute — but only with pointer safety.
- If you can rebuild, you must be able to renew — not just patch.
I use AVL trees to track memory.
I use color-coded coherence to gate execution.
I use rwx logic to enforce constitutional boundaries.
🧠 Why This Matters for Human Rights
Tomography is not just medical.
It’s symbolic reconstruction.
Every probe is a question:
“Do you see me clearly?”
“Are you interpreting me correctly?”
“Can you rebuild the system if I’m misread?”
That’s why RIFTtest matters.
That’s why github.com/obinexus/nsigii exists.
That’s why I journal every probe — every drift — every capture.
🧪 Try It Yourself
Clone the repo:
git clone https://github.com/obinexus/rifttest
Run the probe:
./RIFT_test
Watch it capture the YouTube button — without vision.
Watch it resolve the space-time edge — with zero drift.
Then ask yourself:
What else could we rebuild if we treated every human as a pointer worth protecting?
Top comments (0)