MathSphere Nexus official corporate seal MathSphere Nexus

The Universal MathSphere Nexus Lawbook

November 14, 2026 — by Alexander Sanchez

MathSphere Nexus is a software house, and this is the book of law its software is built under. Every program MathSphere Nexus creates — the ones we publish, and the ones the house runs its own work on — stands under the same laws, in the house’s own numbering. We use this software ourselves, in this house, every day; the law that governs a user’s copy governs ours.

The laws are published so our claims can be checked. Three states are kept separate throughout this book — decided, built, and proven — and where a thing is decided but not yet built, the book says so.

What This Book Is — and What It Is Not

This book is what MathSphere Nexus is, and how it operates. It stands behind every project the way version control stands behind code: quietly, in the background, governing every change before that change reaches you. Software that reaches a user from this house was built, checked, and receipted under these laws before it ever left.

It is not control over your copy. Once the software reaches you, it is yours. We do not reach into it afterward: there is no telemetry, nothing reports back, and we do not version-control your installation. If an update is published, it is yours to take or leave. The laws governed the making; they do not follow the copy home.

Part I — The Universal Laws

1. The Double-Ask. In every project, a destructive action asks twice in the terminal — when a model is involved, and for anything that goes through a model bridge. The first question is the plain ask; the second states what the person is agreeing to, and is answered with a typed, scoped confirmation. Read-only actions never ask.

2. Receipts. Every project is a receipt-providing machine. Actions are receipted for the user’s own accountability, and the receipts are hash-chained, so the record can be checked and cannot quietly change.

3. Demo Sections. Every project carries a demo section, part of every build, in which every feature is tested live and documented as guidance for users.

Part II — The Three Laws of the Record

Law 1 — The User’s Hand. When a user deletes, the item goes to the system’s recycle bin, outside the program. From that point the program has no control; the user erases from there by hand.

Law 2 — The Program’s Hand. When the program itself retires items — rolling them off a storage cap — they go to an in-app archive the user can browse and restore from. Never to the bin.

Law 3 — The Program Never Destroys. Nothing is ever destroyed without the user doing it. There are no destroy or purge commands; the programs refuse them by construction.

The working rules under these laws: the archive has a visible door, and search covers the archive and says when a result was found there. Receipts are visible — an activity view the user can filter and export; reads are receipted too, and shown on request. The archive compacts; it never evicts. A pinned item is exempt from eviction. Confirmations belong only to the user’s hand; the program’s own housekeeping is silent, recoverable, and visible. A storage panel states honestly what is held, and the program’s store is backed up automatically on a schedule. And there is no “write” by a model: a model drafts, the user validates, and only then is anything created — creation receipted to the person who validated it.

Part III — The Gate and the Grants

Within a program, every door shares one gate and one tool-runner; the rules are never re-implemented per command. Two questions bind power — grants, switches, approvals. A model session runs only under a live grant the person gave, and a model can never extend, widen, or renew its own grant. A grant has a scope and a term. Its scope is two-part — an umbrella grant for the session, and folder grants naming where the model may work; both are needed, and with no folder granted the session is conversation only. Its term is set by the person — thirty minutes by default — and expiry is a hard stop: the session ends where the grant ends, and an open-ended term exists only as the person’s typed choice, nolimit. A session grant dies with its session. And the grant is receipted at both ends — when it is given and when it ends — the receipts carrying the grant’s own identifier, so the grant and everything done under it can be matched in the record. Restore, reset, and reverse run only on the user’s own copy, on the user’s own machine — never on the source the software came from. No consent path leads into the source.

Part IV — When Something Fails

Our systems never bare-fail. Where a fallback exists, it is given: a missing or declined piece turns off exactly the feature that needs it — named in plain words, with its remedy — and everything else runs. Where no fallback can be given, for privacy or security reasons, the honest, named failure is the fallback, and debugging is the next step. A built-in guide helps the user debug: it explains failures and refusals in plain words, from their receipts. It advises only; the person’s hand does the fixing, and the system works fully with the guide off. Dependencies are installed at setup, so an absence is never a designed state; when one is absent or unreachable at runtime, the failure is named, with its remedy.

Part V — Sovereignty

Level 0 is the author. Level 1 is the person and their installation — sovereign over their gate, their grants, their receipts, and their creations. Level 2 is everyone else inside the software — providers, guides, models, engines — grantees and advisors, never authorities. Grants flow down, never up. There are no promotion paths. Records belong to the level that made them. Everything is revocable, and everything is receipted.

Part VI — The Arbiter and Its Names

The Arbiter is the house’s integrity tool: it witnesses files and projects, records what it sees in a hash-chained audit log, seals snapshots, and proves — by verification — that what was recorded has not quietly changed. It is a tool, usable by anyone; each user’s copy is that user’s own, on their own machine. MathSphere Nexus provides the software; the use is the user’s.

A note on the name. “Arbiter” is this tool’s name, and we do not convey an arbiter in a legal-standing kind of way. The Arbiter is software: it witnesses, records, and proves. It does not arbitrate disputes, adjudicate, or act in any legal capacity, and nothing in it is a legal judgment or a legal service.

The tool’s full name is MathSphere Nexus Arbiter. Its initials are MNA. It carries a sub-name: ArbiTooling. The sub-name names the act — the recording, snapshotting, sealing, and verifying the tool performs on a user’s disk. An act cannot supersede or overpower the main name, because it is the act, not the tool itself: the name names the tool, and the sub-name names only what the tool does.

The state the act leaves is arbitooled — concretely, arbitooled files: files that have been witnessed, recorded, and made provable. The proof takes the form of filled receipts — Arbitooled_Filled_Receipts — the chain entries the act writes as it works. First the act, then the state it leaves.

MathSphere Nexus Arbiter keeps me arbitooled ready, and arbitooling, keeps my files honest.

On screen and on the receipt, a run of the tool reads in one chain:

MathSphere Nexus Arbiter > MNA > Arbitooling_In_Progress > Arbitooled_Filled_Receipts

When the program begins, it shows Arbitooling_In_Progress. Its receipts show the same marks: the act in progress at the start of a run, the filled receipts at the finish — displayed on the receipt itself, where the user reads it. These display marks are decided, and are being added to the Arbiter’s interface; the laws in this book already govern the software as it stands.

We publish the laws so the claims can be checked — that is the generosity. The software itself keeps what is yours on your machine — that is the privacy. Generous software, with built-in privacy.


A command is what you type. The name is what the project is.

— Alexander

MathSphere Nexus official corporate seal