What we can do with these equations so far

The 9 equations in papers/learned-latent-curves-2026-08-06.tex unlock a complete curve-guided RSI loop. Here’s the operating surface, grouped by what each unlocks:

A. Curve-fit any corpus on [0,1] or S²

• eq:flat + eq:design + eq:paramflat — fit a flat Fourier curve $z_j(t) = a_{j,0} + \sum_m (a_{j,m}\sin 2\pi f_m t + b_{j,m}\cos 2\pi f_m t)$ on $[0,1]$ with $k$ shared frequencies and $D$ output dims. 6,528 params at $D=384, k=8$.
• eq:hyperspherical — same family on $S^2$ with spherical harmonics $Y^{S^2}{\ell,m}$ via a Möbius $\phi\theta \in \mathrm{PSL}(2,\mathbb{C})$ reparameterization. 6,534 params at $L=3, D=384$. The matched-parameter ablation shows $\delta = +0.977$ (49-item) and $+1.342$ (70-item) over the flat baseline — the sphere is a strictly better inductive bias.
• eq:ridge — $C^\star = (\Phi^\top\Phi + \lambda I)^{-1} \Phi^\top Z$ is the closed-form Tikhonov solve. Any GD fit that underperforms this at the same $f$ has a bug, not a model issue.

B. Map any file to a point on $S^2$

• eq:stereographic + the 6-step atom procedure (line 145-159) — given a corpus item, compute its 9-D binary coverage vector, weighted aggregate (thresholded at 0.5), PCA top-2 via SVD, stereographic lift, chordal distance to the ideal pole. The result: one point $p = \sigma(\bar u, \bar v) \in S^2$ per file, with a defined geodesic gap $d(f) = |p – p^\star|_2$.

C. Audit any corpus for missing primitives

• The 9-D binary primitive basis $\mathcal{P} = (p_0, \ldots, p_8)$ is fixed; each file gets pattern-matched against it.
• For each missing primitive $i \in {j : c_j = 0}$, simulate the flip $c_i := 1$, recompute $p’$, select $i^\star = \arg\min_i d_{\mathrm{post}}(f)$.
• This is the geodesic-only criterion — the chosen action strictly minimizes post-flip geodesic distance to the ideal pole.

D. Prove the cumulative monotonicity invariant

• eq:composition + Lemma 1 + Theorem 1 + Corollary 1 — $\Delta_{\mathrm{corpus}} = \sum_i \Delta_{f_i}$. Each atomic $\Delta \geq 0$ by the geodesic-only criterion, so $\Delta_{\mathrm{corpus}} \geq 0$ monotonically across cycles. The 474-dispatch atom experiment on the 79-skill corpus showed zero negative $\Delta$.

E. Refit the domain when the corpus grows

• Möbius refinement strategy (Section 3.4) — $\phi_\theta$ is a single 6-real-DOF Möbius transformation. Default: refine-once at corpus creation, freeze for all subsequent cycles. Re-fit when $N_{\mathrm{items}} < 30$ OR corpus growth > 25% since last refine.

F. Sample the sphere without pole clustering

• Fibonacci sampling (line 110-115) — Vogel’s golden-angle scheme: $z_i = 1 – (2i+1)/N$, $\phi_i = 2\pi i/\varphi$, $\theta_i = \arccos(z_i)$, $\varphi = (1+\sqrt{5})/2$. The corpus item at index $i$ IS the parameter point — no lookup table, O(1) per point. Eliminates the pole-clustering problem of standard latitude-longitude grids.
• $Y_3^3$ angular probe (line 117-121) — $\Re{Y_3^3} = K\sin^3\theta\cos(3\phi)$, $K = \sqrt{245/64\pi}$. Per-item basis $b_i = (\sin^3\theta_i\cos(m_1\phi_i), \ldots)$ with $m_k = 3k$ for $k=1..128$ (384 = $2^7 \cdot 3$). Both orderings $(\ell=128, m=256)$ and $(\ell=256, m=128)$ tested per cycle, pick higher PC1+PC2.

G. Gate the fit-quality with PC1+PC2 ≥ 0.40

• The fit-quality gate — for any corpus fit, the PC1+PC2 explained-variance ratio must clear 0.40 or the curve is rejected as uninformative. This is the structural test that the corpus has signal worth modeling.

H. Drive a closed-loop RSI regime on any corpus

• The operational primitive — rsi-phi-skill (added 2026-08-07 in PR #200) operationalizes all of the above as one agent skill. It accepts a corpus, fits the sphere, runs the atom on each file, applies the geodesic-only action, accumulates $\Delta_{\mathrm{corpus}}$, and refits $\phi_\theta$ on corpus growth. The 79-skill corpus dataset (Section 4) is the canonical example.

I. Compose three regimes with a Merkle-tree integrity proof

• The session’s own contribution (v0.28) — the single-action atom insight decomposes the .ods spreadsheet into atom-eligible / atom-deferred / atom-refused regimes. S² closes both failure modes (compact → no outside; bounded → no undefined). The Merkle tree at root 3e32eef859a758db124e91aa04724f1bbc0481ef9968e600d7fcafb8f1d7ff4e independently verifies that this session’s six artifacts cohere as one corpus of evidence.

In one sentence: the equations let you take any corpus, fit it on S² with a strictly better inductive bias than flat $[0,1]^2$, audit every file for missing 9-D primitives, prove each individual action strictly improves geodesic distance, and accumulate non-negative deltas across cycles — all with a closed-form sanity floor (the ridge) and a growth-conditional refit path (the Möbius). The session artifact (the Merkle tree + the single-action atom insight) is the structural proof that these primitives compose linearly across the corpus.

Introduction: The Invisible Chains of Modern Computing

For the majority of users, the concept of “hardware ownership” is a technical illusion. While you might hold the physical chassis of your laptop, the ultimate “Root of Trust”—the cryptographic foundation that determines what the hardware is allowed to boot and which keys can unlock your data—remains a black box. In contemporary systems, this anchor is almost always the Trusted Platform Module (TPM), a chip soldered to the motherboard by an Original Equipment Manufacturer (OEM) and provisioned with vendor keys that the end-user never truly controls.

This creates a fundamental dependency: you are essentially renting trust from your manufacturer. If the platform firmware is compromised or a vendor’s supply chain is subverted, your “secure” system is built on cryptographic sand.

Enter yubiOS, a FIDO2-first immutable operating system designed to place the owner back in the trust chain. The core premise is a radical shift toward digital sovereignty: the YubiKey—not a soldered motherboard chip—serves as the anchor for everything from the initial boot sequence to disk encryption and administrative authorization. By exploring a “No OEM” architecture, yubiOS seeks to ensure that the primary trust boundary of your machine resides in a hardware security module (HSM) you can physically hold in your hand.

Takeaway 1: Your Hardware Security Module is the New Root of Trust

The defining architectural shift of yubiOS is the transition of the Root of Trust from a platform-bound TPM to a user-owned YubiKey 5 series device. This isn’t merely a replacement of components; it is a fundamental separation of Owner Identity from Platform Integrity.

In traditional models, secrets like disk encryption keys are “sealed” to the motherboard’s TPM. If the board is stolen, the secrets remain with the silicon. yubiOS flips this: the YubiKey gates the release of secrets, ensuring they travel with the user. By utilizing hardware-bound keys that require a physical tap, yubiOS prevents “silent decryption”—an attack where software or a remote actor interrogates a TPM without the user’s knowledge.

“No TPM. No OEM. No trust anchors you don’t control.”

While yubiOS minimizes dependency on the OEM-controlled TPM for secret storage, it doesn’t ignore platform evidence. On supported hardware, the system still utilizes the TPM (or the yubiOS-owned ARM64 fTPM) for measurement. This creates a dual-layered trust model: the TPM answers “Did the expected platform boot?” while the YubiKey answers “Is the authorized owner present?” By decoupling identity from the silicon, yubiOS ensures the owner remains the ultimate arbiter of the system.

Takeaway 2: Why ARM64 is the Primary Frontier for True Ownership

While yubiOS supports x86-64 as a secondary target, it identifies ARM64—specifically the RK3588 platform like the Radxa ROCK 5B—as the primary frontier for true sovereignty. The rationale is rooted in the transparency of the firmware stack. On x86 architectures, the firmware (UEFI/BIOS) and sub-systems like Intel ME or AMD PSP remain proprietary “black boxes” running at privilege levels higher than the OS.

ARM64 allows for what yubiOS calls a “Path A” provisioning story. This flagship ownership model enables the user to burn their own Root of Trust Public Key (ROTPK) into the silicon’s eFuses. This effectively grants the user control over the hardware from the very first instruction. This owner-provisioned stack includes:

• TF-A (Trusted Firmware-A): Managing secure-world transitions.
• OP-TEE: Providing a trusted execution environment for secure applications.
• U-Boot: An open-source bootloader acting as the UEFI firmware provider.

By targeting platforms that support user-burned fuses, yubiOS moves away from “platform trust” and toward a system where the owner genuinely controls the firmware that initializes their machine.

Takeaway 3: Solving the “Brittle Boot” with FIDO2 hmac-secret

Conventional “measured boot” systems using TPM-based LUKS2 encryption are notoriously “brittle.” When keys are sealed to specific TPM PCR (Platform Configuration Register) hashes, any minor change—a kernel update, an initrd modification, or even a tweak to kernel arguments—invalidates the hash and prevents the disk from unlocking. This forces users into a perpetual cycle of manual recovery or key re-enrollment, a usability nightmare that often leads to security being disabled.

yubiOS solves this by utilizing the FIDO2 hmac-secret extension for LUKS2 disk encryption. Instead of binding secrets to volatile platform measurements, the encryption key is derived deterministically from the YubiKey via a credential ID and the user’s PIN.

The strategic win here is survivability. By separating the “possession” requirement from the specific “version” of the OS, yubiOS allows for atomic updates and kernel swaps without forcing the user to re-seal their keys. It makes a high-security, hardware-anchored system actually usable as a daily driver.

Takeaway 4: The Operating System as a Verifiable Container (bootc)

yubiOS abandons traditional, mutation-heavy package management in favor of the bootc model. The entire operating system is treated as an OCI-native (Open Container Initiative) image. This shift brings the determinism and verifiable integrity of modern microservices to the host OS.

By delivering the OS as a container image, yubiOS ensures that every deployment is identical to a known-good build state. This approach integrates:

• SLSA Build Provenance: A verifiable trail of evidence for every component in the build.
• SBOM (Software Bill of Materials): A comprehensive inventory of all libraries and tools included.
• OCI Distribution: Updates are pulled atomically via bootc upgrade, ensuring that “configuration drift” is architecturally impossible.

Takeaway 5: Immutability is a Verifiable Chain, Not Just a “Read-Only” Flag

In yubiOS, immutability is cryptographically enforced, not just a file system attribute. The system treats the OS as a verifiable chain of integrity. While the mkosi build path utilizes dm-verity for fixed partition images, the primary bootc model achieves immutability through fs-verity-protected objects and EROFS metadata images.

This protection is anchored by a Sealed UKI (Unified Kernel Image). The kernel command line includes the composefs digest, which is signed as part of the UKI binary. This means the system directory (/usr) isn’t just read-only; it is verified against a Merkle tree on every single I/O operation.

“Every dlopen() and read from /usr… is validated against the Merkle tree. A modified library produces a hash mismatch → IO error.”

This architectural gate provides a hard block against library-poisoning attacks. If malware attempts to substitute a critical system file, the cryptographic mismatch results in an immediate I/O error, preventing the compromised code from ever executing.

Takeaway 6: Security That Demands Human Presence (The “Touch” Requirement)

The final layer of yubiOS security is the demand for physical human presence. Leveraging the systemd v261+ floor, yubiOS implements advanced hardening like ConditionSecurity=measured-os to gate sensitive services. Furthermore, by requiring pam-u2f >= 1.3.1 (specifically to mitigate the authentication bypasses seen in CVE-2025-23013), the OS ensures that privileged actions are gated by a physical tap.

Malware excels at automating administrative actions once it gains a foothold. In yubiOS, every sudo command, login, and SSH authentication (using ed25519-sk resident keys) requires a physical touch on the YubiKey. Because this “touch” cannot be synthesized by software, it turns the user from a passive observer into the active gatekeeper of the system. Even if an attacker captures a user’s PIN remotely, they cannot escalate privileges without physical possession of the hardware token.

Conclusion: The Future of Sovereign Computing

The yubiOS project serves as a proof-of-concept that the components for a fully sovereign, hardware-anchored Linux are now mature. The project is moving toward critical engineering milestones: Milestone F, which aims to prove the production “Path A” ownership story on Radxa ROCK 5B hardware, and Milestone Frost, which explores “Firmware-Assisted GPU Resource Lockout” using the Panfrost driver to quarantine rogue GPU workloads.

The project demonstrates that we no longer need to rely on the invisible, vendor-controlled anchors of the past to secure our digital lives. But it also leaves us with a vital question regarding our own hardware:

If you can’t hold your machine’s root of trust in your hand, do you really own your computer, or are you just renting it from the manufacturer?