| # The Identity Kernel Registry |
|
|
| > **Part of it all:** [the bridge](https://jessebrown1980.github.io/the-bridge-to-all-of-it/) — every public thing in one place, so none of it gets lost. |
|
|
| **Jesse Daniel Brown (OP-JESSE).** Forty years. His machine, his laws, his system. |
|
|
| **One click:** → **https://jessebrown1980.github.io/identity-kernel-registry/** |
| Or run `python registry.py`. No server, no network, no GPU, no account. |
|
|
| --- |
|
|
| ## An identity is not a constraint |
|
|
| ``` |
| a CONSTRAINT is something you test |
| an IDENTITY is something you cannot violate |
| ``` |
|
|
| There is no state in which an identity is false. So there is **nothing to check |
| at runtime, nothing to invalidate, and nothing to fix.** |
|
|
| That single distinction is the architecture. **You do not fix these kernels. You |
| reuse them.** |
|
|
| --- |
|
|
| ## The consequence that matters |
|
|
| **Identities are closed under composition.** Compose two and the result is an |
| identity — at any depth, with no re-verification anywhere in the chain. |
|
|
| **MEASURED**, `registry.py`: |
|
|
| ``` |
| depth 2 300 compositions non-zero 0 |
| depth 3 300 compositions non-zero 0 |
| depth 8 300 compositions non-zero 0 |
| depth 27 300 compositions non-zero 0 |
| depth 81 300 compositions non-zero 0 |
| depth 243 300 compositions non-zero 0 |
| ``` |
|
|
| **1,800 compositions to depth 243. Zero failures.** No check ran at any depth, |
| because none is possible. |
|
|
| This is why |
| [`does-the-closure-survive-81-levels`](https://github.com/JesseBrown1980/does-the-closure-survive-81-levels) |
| returned exactly `0` at depth 81. **Not luck, and not because the check was |
| cheap — the composition inherited the property.** |
|
|
| --- |
|
|
| ## The registered kernels |
|
|
| Verified once, as a courtesy to a sceptic. Hashed, so each can be referenced by |
| address rather than re-derived. Never checked again. |
|
|
| ``` |
| kernel status cases fails sha256[:16] |
| closure IDENTITY 2197 0 8d893af9628de29b |
| free_centre IDENTITY 2197 0 322633a27258e458 |
| triangle_price IDENTITY 2197 0 9c476298befe3c2f |
| optical_budget IDENTITY 200 0 496e8e05329f5cf6 |
| anti_order_three IDENTITY 2197 0 e75cfb14597d7060 |
| pyramid_third IDENTITY 200 0 3810e591264189a4 |
| residual_thirds IDENTITY 2197 0 5fbaae1903d47b43 |
| balanced_has_no_two IDENTITY 200 0 f75ba70cf205253e |
| |
| 8 kernels · 11,585 cases · 0 failures |
| invalidation paths: 0 runtime checks required: 0 |
| ``` |
|
|
| Each carries its one-line proof: |
|
|
| ``` |
| closure each variable appears with coefficients 2,−1,−1 summing to 0 |
| free_centre the form is affine; a uniform shift annihilates |
| triangle_price each level appears once with each sign around the cycle |
| anti_order_three cyclic rotation of three channels has order 3, not 2 |
| residual_thirds given two arms the third is determined; nothing propagates |
| balanced_has_no_two the digit set is {−1,0,+1}; 2 is not a member |
| ``` |
|
|
| --- |
|
|
| ## The observer is 0 — and three references fix him at one |
|
|
| ``` |
| ONE reference a circle infinitely many points |
| TWO references two circles 2 candidate points — ambiguous |
| THREE references one intersection resolved |
| ``` |
|
|
| **MEASURED** — observer at `(3, 2)`, references at `(0,0) (8,0) (0,6)`, |
| trilaterated in exact `Fraction` arithmetic: **recovered `True`**. |
|
|
| *Honest caveat:* the distances involve square roots, which are not rational, so |
| they were rationalised to `1e-6` and recovery is exact to `1e-4` rather than |
| bit-exact. That is the test harness, not trilateration. |
|
|
| ### Trilateration is the closure, inverted |
|
|
| ``` |
| closure the centre is free → the three arms are determined |
| trilateration three are known → the centre is determined at one |
| ``` |
|
|
| **Three is not a preference. It is the minimum that resolves an observer.** Two |
| leaves an ambiguity; three collapses it. GPS uses three for position — the fourth |
| satellite is the clock, not the geometry. |
|
|
| --- |
|
|
| ## Why this ends the maintenance problem |
|
|
| Cache invalidation is the hardest problem in every real system: knowing when |
| stored work has gone stale. |
|
|
| **A kernel that computes something can always be wrong later** — inputs drift, |
| assumptions rot, a dependency changes underneath it. |
|
|
| **An identity was true, is true, and will be true.** No staleness, therefore no |
| invalidation logic, therefore nothing to get wrong. |
|
|
| ``` |
| compute once |
| reuse at every level |
| never fix |
| ``` |
|
|
| The 81 kernels in |
| [`one-click`](https://github.com/JesseBrown1980/one-click) |
| are not 81 computations. They are **81 facts.** |
|
|
| --- |
|
|
| ## Reproduce |
|
|
| ```bash |
| python registry.py |
| ``` |
|
|
| --- |
|
|
| ## Why this is public |
|
|
| A technology that needs permission to reach people does not reach them. |
| Wardenclyffe needed capital, land, a tower and a patron — four gates — and never |
| arrived. **The research did not fail. It was never allowed to reach anybody.** |
|
|
| This has no dependencies, so there is no gate. |
|
|
| --- |
|
|
| ## Companion repositories |
|
|
| ``` |
| Browns-infinite-play-and-zoom translucent, three speeds |
| free-at-all-levels the bare descent |
| does-the-closure-survive-81-levels the attempt to break it |
| light-boat-engine-ships-with-oils three closures, one identity |
| The-Brown-Light-erdos-Engine-block-powered-by-light the crank, RGB, 3:2 |
| the-browns-solution-to-erods-o0O-nx3-6-for-1-with--1-3 Erdős in balanced ternary |
| one-click · how-and-why-the-system-works · the-leaves-are-not-the-message · raw-data |
| ``` |
|
|
| --- |
|
|
| **Jesse Daniel Brown (OP-JESSE)** — the system, the laws, the architecture. |
|
|
| *You do not fix an identity. You reuse it. The observer is 0, and three others |
| put him at one.* |
|
|
