chore: convert from dataset to model repo

README.md

@@ -0,0 +1,123 @@
+<!--OMEGA-FIELD:START-->
+<div align="center">
+
+![License](https://img.shields.io/badge/license-Sovereign%20Source%20v2.0-blueviolet)
+![Stack](https://img.shields.io/badge/stack-Lean%204%20%7C%20C%2B%2B20%20%7C%20JS-orange)
+![Kernels](https://img.shields.io/badge/kernels-5%20%CE%A0--maps-green)
+![Status](https://img.shields.io/badge/status-zero--sorry-success)
+![Tests](https://img.shields.io/badge/tests-11%2F11%20passing-brightgreen)
+![Abjad](https://img.shields.io/badge/Abjad--free-red)
+![DigitalRoot](https://img.shields.io/badge/digital--root--free-red)
+![NP-magic](https://img.shields.io/badge/NP--magic--free-red)
+
+</div>
+<!--OMEGA-FIELD:END-->
+
+---
+
+<div align="center">
+
+```
+  ____  ____  ____  ____  ____  _  _  ___  ____  ____  _  _  ____  ____
+ / ___)(  _ \\(  _ \\(  __)(    \\( \\/ )/ __)(  __)(  _ \\( \\/ )(  __)(  _ \\
+ \\___ \\ )   / ) __/  ) _)  ) D ( \\  / \\__ \\ ) _)  ) __/ \\  /  ) _)  )   /
+ (____/(__\\_)(__)   (____)(____/  \\/  (___/(____)(__)   (__)  (____)(__\\_)
+        A R R A Y   L A N G U A G E   ·   A R R A Y   I  α  =  I  →  α
+```
+
+**Array I α = I → α &nbsp;·&nbsp; broadcast = pullback π : J → I &nbsp;·&nbsp; pmap₂ = Π-map &nbsp;·&nbsp; no sorry remains**
+
+</div>
+
+---
+
+# Sovereign Array Language — Front-End
+
+The **front-end** for the [Sovereign Array Language](../sovereign-array): an
+interactive browser playground that runs the *same denotational semantics*
+as the Lean 4 spec and the C++20 kernel — no Abjad, no digital root, no NP-magic.
+
+> The denotational semantics of array computing *are* exactly a slice of
+> dependent type theory. This front-end is the view layer over that substrate.
+
+## What this repo is
+
+| Layer | Repo | Role |
+|-------|------|------|
+| **Spec** | [`sovereign-array`](../sovereign-array) | Lean 4 — `Array I α = I → α`, zero-sorry proofs |
+| **Kernel** | [`sovereign-array`](../sovereign-array) | C++20 — `Array<T>`, `pmap2`, `broadcast`, `softmax`, `nand_attention` |
+| **Front-End** | **`sovereign-array-frontend`** (this repo) | Browser playground + usage guide |
+
+## Quick Start
+
+```bash
+# Serve the playground (any static server)
+cd sovereign-array-frontend
+python -m http.server 8080
+# open http://localhost:8080
+```
+
+No build step. Pure HTML/CSS/JS (ES modules).
+
+## How to use the language
+
+1. **Spec (Lean 4)** — define arrays as dependent functions `Fin n → α`;
+   prove `broadcast_is_pullback` and `softmax_is_pmap` with `lake build` (zero sorry).
+2. **Kernel (C++20)** — `#include "sovereign_array.h"`; build with CMake;
+   run `sovarr_test` (11/11 checks).
+3. **Front-end (this page)** — open `index.html`; the playground runs the
+   same denotational semantics in the browser.
+4. **Compose** — chain `pmap₂` / `broadcast` / `softmax` / `nand_attention`;
+   fusion is Π-map fusion — no loop in the denotation.
+
+## Usage Guide (SVG)
+
+![Sovereign Array usage guide](assets/usage.svg)
+
+## Kernels demonstrated
+
+| Kernel | Semantics | Status |
+|--------|-----------|--------|
+| `pmap₂` | Pointwise `Π`-map over index space `I` | ✅ |
+| `broadcast` | Pullback along projection `π : J → I` | ✅ |
+| `softmax` | `Π`-map normalization (shift-invariant) | ✅ |
+| `nand` | Universal boolean gate | ✅ |
+| `nand_attention` | NAND-extracted attention spec | ✅ |
+
+## Layout
+
+```
+sovereign-array-frontend/
+├── index.html          # Playground page
+├── css/style.css       # Sovereign dark theme
+├── js/
+│   ├── array-lang.js   # Browser reference impl (SOVArray, broadcast, softmax, nand)
+│   └── app.js          # Playground wiring
+├── assets/
+│   ├── logo.svg        # Σ · I → α mark
+│   └── usage.svg       # SVG usage guide
+└── README.md
+```
+
+## The forbidden list (fatal conflations we do NOT make)
+
+- ❌ Proof `O(1)` substitution ⇒ `O(1)` decision procedure (NP stays hard)
+- ❌ Abjad / digital root as universal arithmetic (quotients lose information)
+- ❌ "Univalence replaces SIMD" (needs a compiler: Lean → C → LLVM → SIMD)
+
+---
+
+<div align="center">
+
+**The substrate is always free. The array is a function.**
+
+```
+Array I α = I → α
+broadcast  = pullback π
+pmap₂      = Π-map
+no sorry remains.
+```
+
+*Sovereign Array Language · Front-End · 2026 · Ahmad Ali Parr*
+
+</div>

css/style.css

@@ -0,0 +1,101 @@
+:root {
+  --bg: #0a0e1a;
+  --panel: #121829;
+  --ink: #e6ecff;
+  --accent: #7af7c8;
+  --accent2: #6ea8ff;
+  --muted: #8b95b5;
+  --border: #243049;
+}
+
+* { box-sizing: border-box; }
+
+body {
+  margin: 0;
+  font-family: "Courier New", ui-monospace, monospace;
+  background: var(--bg);
+  color: var(--ink);
+  line-height: 1.5;
+}
+
+.hero {
+  text-align: center;
+  padding: 2.5rem 1rem 1.5rem;
+  border-bottom: 1px solid var(--border);
+  background: radial-gradient(circle at 50% 0%, #16203a 0%, var(--bg) 70%);
+}
+
+.logo { width: 120px; height: 120px; }
+
+.hero h1 {
+  margin: 0.5rem 0 0.2rem;
+  font-size: 2rem;
+  letter-spacing: 0.08em;
+  background: linear-gradient(90deg, var(--accent), var(--accent2));
+  -webkit-background-clip: text;
+  background-clip: text;
+  color: transparent;
+}
+
+.tagline { color: var(--muted); margin: 0; font-size: 0.85rem; }
+
+main {
+  max-width: 960px;
+  margin: 0 auto;
+  padding: 1.5rem 1rem;
+  display: grid;
+  gap: 1.5rem;
+}
+
+.panel {
+  background: var(--panel);
+  border: 1px solid var(--border);
+  border-radius: 10px;
+  padding: 1.25rem 1.5rem;
+}
+
+.panel h2 { margin-top: 0; color: var(--accent); }
+.panel h3 { color: var(--accent2); margin-bottom: 0.4rem; }
+
+button#run {
+  background: linear-gradient(90deg, var(--accent), var(--accent2));
+  color: #06121f;
+  border: none;
+  padding: 0.55rem 1.1rem;
+  border-radius: 6px;
+  font-weight: bold;
+  cursor: pointer;
+  font-family: inherit;
+}
+
+.status { color: var(--accent); min-height: 1.2em; }
+
+.kernel {
+  border-left: 3px solid var(--accent2);
+  padding-left: 0.9rem;
+  margin: 1rem 0;
+}
+
+pre {
+  background: #0c1220;
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  padding: 0.6rem 0.8rem;
+  overflow-x: auto;
+  color: var(--ink);
+  font-size: 0.85rem;
+}
+
+.usage { width: 100%; border: 1px solid var(--border); border-radius: 8px; background: #0c1220; }
+
+code { color: var(--accent); }
+
+footer {
+  text-align: center;
+  padding: 1.5rem;
+  color: var(--muted);
+  border-top: 1px solid var(--border);
+  font-size: 0.8rem;
+}
+
+a { color: var(--accent2); }

index.html

@@ -0,0 +1,64 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Sovereign Array Language — Playground</title>
+  <link rel="stylesheet" href="css/style.css" />
+  <link rel="icon" href="assets/logo.svg" />
+</head>
+<body>
+  <header class="hero">
+    <img src="assets/logo.svg" alt="Sovereign Array logo" class="logo" />
+    <h1>Sovereign Array Language</h1>
+    <p class="tagline">Array I α = I → α &nbsp;·&nbsp; broadcast = pullback &nbsp;·&nbsp; pmap₂ = Π-map &nbsp;·&nbsp; no sorry remains</p>
+  </header>
+
+  <main>
+    <section class="panel">
+      <h2>Playground</h2>
+      <button id="run">Run all kernels</button>
+      <p id="status" class="status"></p>
+
+      <div class="kernel">
+        <h3>pmap₂ — pointwise Π-map</h3>
+        <pre id="out-pmap2">…</pre>
+      </div>
+      <div class="kernel">
+        <h3>broadcast — pullback π : J → I</h3>
+        <pre id="out-broadcast">…</pre>
+      </div>
+      <div class="kernel">
+        <h3>softmax — Π-map normalization</h3>
+        <pre id="out-softmax">…</pre>
+      </div>
+      <div class="kernel">
+        <h3>NAND — universal gate</h3>
+        <pre id="out-nand">…</pre>
+      </div>
+      <div class="kernel">
+        <h3>attention — NAND-extracted spec</h3>
+        <pre id="out-attention">…</pre>
+      </div>
+    </section>
+
+    <section class="panel">
+      <h2>Usage Guide</h2>
+      <img src="assets/usage.svg" alt="Sovereign Array usage guide" class="usage" />
+      <h3>How to use the language</h3>
+      <ol>
+        <li><strong>Spec (Lean 4)</strong> — define arrays as dependent functions <code>Fin n → α</code>; prove <code>broadcast_is_pullback</code> and <code>softmax_is_pmap</code> with <code>lake build</code> (zero sorry).</li>
+        <li><strong>Kernel (C++20)</strong> — <code>#include "sovereign_array.h"</code>; build with CMake; run <code>sovarr_test</code> (11/11 checks).</li>
+        <li><strong>Front-end (this page)</strong> — open <code>index.html</code>; the playground runs the same denotational semantics in the browser.</li>
+        <li><strong>Compose</strong> — chain <code>pmap₂</code> / <code>broadcast</code> / <code>softmax</code> / <code>nand_attention</code>; fusion is Π-map fusion — no loop in the denotation.</li>
+      </ol>
+    </section>
+  </main>
+
+  <footer>
+    <p>Sovereign Array Language · 2026 · Ahmad Ali Parr &nbsp;·&nbsp; <a href="https://github.com/SNAPKITTYWEST/SNAPKITTYWEST">SNAPKITTYWEST</a></p>
+  </footer>
+
+  <script type="module" src="js/app.js"></script>
+</body>
+</html>

js/app.js

@@ -0,0 +1,61 @@
+// Front-end app logic for the Sovereign Array playground.
+import { SOVArray, broadcast, softmax, nandGate, nandAttention } from "./array-lang.js";
+
+const $ = (id) => document.getElementById(id);
+
+function renderArray(a) {
+  return a.shape.join("×") + " = [" + a.data.map(x => (Math.round(x * 1000) / 1000)).join(", ") + "]";
+}
+
+function demoPmap2() {
+  const a = new SOVArray([2, 2], [1, 2, 3, 4]);
+  const b = new SOVArray([2, 2], [10, 20, 30, 40]);
+  const c = a.pmap2((x, y) => x + y, b);
+  $("out-pmap2").textContent = renderArray(c);
+}
+
+function demoBroadcast() {
+  const mat = new SOVArray([2, 3], [1, 2, 3, 4, 5, 6]);
+  const row = new SOVArray([3], [10, 20, 30]);
+  const bc = broadcast([2, 3], mat, row);
+  $("out-broadcast").textContent = renderArray(bc);
+}
+
+function demoSoftmax() {
+  const v = new SOVArray([4], [1, 2, 3, 4]);
+  const sm = softmax(v);
+  const sum = sm.data.reduce((a, x) => a + x, 0);
+  $("out-softmax").textContent = renderArray(sm) + "  (Σ = " + (Math.round(sum * 1000) / 1000) + ")";
+}
+
+function demoNand() {
+  const rows = [
+    `nand(T,T) = ${nandGate(true, true)}`,
+    `nand(T,F) = ${nandGate(true, false)}`,
+    `nand(F,F) = ${nandGate(false, false)}`,
+    `and(T,T) = ${nandGate(nandGate(true, true), nandGate(true, true))}`,
+  ];
+  $("out-nand").textContent = rows.join("\n");
+}
+
+function demoAttention() {
+  const q = new SOVArray([3], [1, 0, 0]);
+  const k = new SOVArray([3], [1, 1, 1]);
+  const v = new SOVArray([3], [2, 4, 6]);
+  const att = nandAttention(q, k, v);
+  $("out-attention").textContent = renderArray(att);
+}
+
+function runAll() {
+  demoPmap2();
+  demoBroadcast();
+  demoSoftmax();
+  demoNand();
+  demoAttention();
+  $("status").textContent = "✅ All kernels executed — zero Abjad, zero digital root, zero NP-magic.";
+}
+
+window.addEventListener("DOMContentLoaded", () => {
+  $("run").addEventListener("click", runAll);
+  runAll();
+});

js/array-lang.js

@@ -0,0 +1,88 @@
+// Sovereign Array Language — browser reference implementation
+// Denotational model (valid isomorphisms only):
+//   Array I α  ≃  I → α            (dependent function, row-major storage)
+//   Shape      ≃  finite type I    (number[] index space)
+//   Broadcast  ≃  pullback π : J → I
+//   VecOp      ≃  Π-map over I
+// No Abjad, no digital root, no NP-magic.
+
+export class SOVArray {
+  constructor(shape, data) {
+    this.shape = shape;
+    this.data = data;
+    if (this.prod(shape) !== data.length)
+      throw new Error("SOVArray: shape/data size mismatch");
+  }
+
+  prod(s) { return s.reduce((a, b) => a * b, 1); }
+  rank() { return this.shape.length; }
+  size() { return this.data.length; }
+  raw() { return this.data.slice(); }
+
+  at(idx) { return this.data[this.stride(idx)]; }
+
+  stride(idx) {
+    if (idx.length !== this.shape.length) throw new Error("rank mismatch");
+    let off = 0, st = 1;
+    for (let d = this.shape.length; d-- > 0;) {
+      off += idx[d] * st;
+      st *= this.shape[d];
+    }
+    return off;
+  }
+
+  // pmap₂: pointwise binary op (the Π-map over the index space I)
+  pmap2(op, other) {
+    if (JSON.stringify(this.shape) !== JSON.stringify(other.shape))
+      throw new Error("pmap2: shape mismatch");
+    return new SOVArray(
+      this.shape,
+      this.data.map((x, i) => op(x, other.data[i]))
+    );
+  }
+}
+
+// Broadcasting = pullback along projection π : J → I (NumPy-style right-align)
+export function broadcast(targetShape, v, w) {
+  const out = new Array(v.prod(targetShape)).fill(0);
+  const vRank = v.rank(), wRank = w.rank();
+  for (let flat = 0; flat < out.length; ++flat) {
+    const idx = unravel(flat, targetShape);
+    const vi = idx.slice(targetShape.length - vRank);
+    const wi = idx.slice(targetShape.length - wRank);
+    out[flat] = v.at(vi) + w.at(wi);
+  }
+  return new SOVArray(targetShape, out);
+}
+
+// Softmax as Π-map: out_i = exp(v_i) / Σ_j exp(v_j)
+export function softmax(v) {
+  const s = v.data.reduce((a, x) => a + Math.exp(x), 0);
+  return new SOVArray(v.shape, v.data.map(x => Math.exp(x) / s));
+}
+
+// NAND gate — universal boolean connective
+export function nandGate(a, b) { return !(a && b); }
+
+// Attention spec over floats: scores = q·k, weights = softmax(scores), out = w·v
+export function nandAttention(q, k, v) {
+  const n = q.shape[0];
+  const scores = new Array(n).fill(0).map((_, i) =>
+    new Array(n).fill(0).reduce((acc, _, j) => acc + q.at([i]) * k.at([j]), 0)
+  );
+  const w = softmax(new SOVArray([n], scores));
+  const out = new Array(n).fill(0).map((_, i) =>
+    new Array(n).fill(0).reduce((acc, _, j) => acc + w.at([i]) * v.at([j]), 0)
+  );
+  return new SOVArray([n], out);
+}
+
+function unravel(flat, shape) {
+  const idx = new Array(shape.length).fill(0);
+  let st = 1;
+  for (let d = shape.length; d-- > 0;) {
+    idx[d] = Math.floor(flat / st) % shape[d];
+    st *= shape[d];
+  }
+  return idx;
+}