@descix/egpt-math-sdk 0.1.0

package/dist/notebooks/matrix.html

@@ -0,0 +1,202 @@
+<frqtl-notebook version="1" title="Matrix Multiplication via the Polynomial Bijective Chain — EGPTMatrix GEMM">
+
+<cell type="markdown">
+# Matrix Multiplication via the Polynomial Bijective Chain
+
+Classical matrix multiplication multiplies two *n × n* matrices in O(n³) operations, touching every element three times. EGPT takes a different route: each matrix row **is** a polynomial in coefficient form, so the dot product of two vectors becomes the (n−1)-th coefficient of a polynomial product. The entire GEMM operation routes through `EGPTPolynomial.multiply` — no Vandermonde, no Toeplitz table, no twiddle precomputation.
+
+This is not notation — it is the implementation. The bijective chain is Lean-formalized in `Translation5.lean` (`(Matrix × Matrix) ≃ ℕ × ℕ`) with closure `{propext, Quot.sound}`. Results are exact rational arithmetic end-to-end; `toMathString()` at the output boundary reads the canonical rational form.
+
+Every cell in this notebook reaches its compute through the single injected `math` builtin. No URL imports, no hardcoded backend labels.
+</cell>
+
+<cell type="js" lane="math" id="backend">
+// Derive the active math backend — never hardcode.
+const { math, display } = caps;
+const backend = math.activeMathBackend;
+display(`Active math backend (derived): ${backend}`);
+</cell>
+
+<cell type="markdown">
+## 1. Constructing matrices with `EGPTMatrix.from`
+
+`EGPTMatrix.from` accepts a rectangular array of JS values and converts each entry to an `EGPTReal`. BigInt literals (`1n`, `2n`, …) are the most explicit form for integer entries — they map directly to `EGPTReal.fromBigInt` with no numeric-precision ambiguity.
+
+The result is a plain 2-D array of `EGPTReal` instances — a representation that is simultaneously a matrix and a polynomial system (each row is a polynomial's coefficient list).
+</cell>
+
+<cell type="js" lane="math" id="construct-matrices" out="A, B">
+const { math, display } = caps;
+const { EGPTMatrix } = math;
+
+// A and B are the two 2×2 matrices from the original demo.
+const A = EGPTMatrix.from([
+  [1n, 2n],
+  [3n, 4n]
+]);
+
+const B = EGPTMatrix.from([
+  [5n, 6n],
+  [7n, 8n]
+]);
+
+display('A =');
+display(EGPTMatrix.format(A, 'A'));
+display('B =');
+display(EGPTMatrix.format(B, 'B'));
+
+return { A, B };
+</cell>
+
+<cell type="markdown">
+## 2. How the dot product becomes polynomial multiplication
+
+The key identity: for two vectors **a** = [a₀, a₁, …, aₙ₋₁] and **b** = [b₀, b₁, …, bₙ₋₁], the dot product Σᵢ aᵢ·bᵢ equals the (n−1)-th coefficient of `P_a(x) · P_b_reversed(x)`, where `P_b_reversed` places the entries of **b** in reverse order as polynomial coefficients.
+
+Convolution at index n−1 picks up exactly Σ_{i+j=n−1} aᵢ · b_{n−1−j} = Σᵢ aᵢ · bᵢ.
+
+`EGPTMatrix.dotViaPolynomial` implements this directly; `EGPTMatrix.gemm` calls it for every (row, column) pair. No scalar multiply-and-accumulate loop, no force equation — just a coefficient extraction from a polynomial product.
+</cell>
+
+<cell type="js" lane="math" id="dot-product-demo" in="A, B">
+const { math, display } = caps;
+const { EGPTMatrix } = math;
+const { A, B } = inputs;
+
+// Demonstrate the dot-product identity directly on row 0 of A and col 0 of B.
+// Row 0 of A  = [1, 2]
+// Col 0 of B  = [5, 7]
+// Expected dot = 1·5 + 2·7 = 19
+const rowA0 = A[0];           // [EGPTReal(1), EGPTReal(2)]
+const colB0 = [B[0][0], B[1][0]];  // [EGPTReal(5), EGPTReal(7)]
+
+const dot = EGPTMatrix.dotViaPolynomial(rowA0, colB0);
+display(`dot(A[0], B[:,0]) via polynomial = ${dot.toMathString()}  (expected 19)`);
+</cell>
+
+<cell type="markdown">
+## 3. GEMM — full matrix-matrix product
+
+`EGPTMatrix.gemm(A, B)` computes C = A · B by applying the polynomial dot-product identity to every (row of A, column of B) pair. The result entries are exact `EGPTReal` rationals read out by `toMathString()`.
+
+Expected result for these inputs:
+
+```
+A · B = [ [1·5+2·7,  1·6+2·8],  =  [ [19, 22],
+           [3·5+4·7,  3·6+4·8] ]       [43, 50] ]
+```
+</cell>
+
+<cell type="js" lane="math" id="gemm" in="A, B" out="C">
+const { math, display } = caps;
+const { EGPTMatrix } = math;
+const { A, B } = inputs;
+
+const C = EGPTMatrix.gemm(A, B);
+
+// Render as string grid for readability.
+const Cstr = C.map(row => row.map(v => v.toMathString()));
+display('C = A · B (via EGPTPolynomial.multiply):');
+display(EGPTMatrix.format(C, 'C = A·B'));
+
+return { C };
+</cell>
+
+<cell type="markdown">
+## 4. Verification — exact rational comparison
+
+EGPT arithmetic is exact. Comparing matrix entries with `toMathString()` (or `EGPTMatrix.equals`) gives a bit-identical answer — no floating-point rounding, no tolerance band. The check below asserts the four entries of C against the expected values and throws on any mismatch (matching the original demo's error semantics).
+</cell>
+
+<cell type="js" lane="math" id="verify" in="C">
+const { math, display } = caps;
+const { C } = inputs;
+
+const expected = [["19","22"],["43","50"]];
+let passed = true;
+const failures = [];
+
+for (let i = 0; i < 2; i++) {
+  for (let j = 0; j < 2; j++) {
+    const got = C[i][j].toMathString();
+    const want = expected[i][j];
+    if (got !== want) {
+      passed = false;
+      failures.push(`C[${i}][${j}]: got ${got}, expected ${want}`);
+    }
+  }
+}
+
+if (!passed) {
+  throw new Error("Matrix multiplication verification failed: " + failures.join("; "));
+}
+
+display(`All 4 entries verified exact: C[0][0]=19, C[0][1]=22, C[1][0]=43, C[1][1]=50`);
+display(`Verification: PASS`);
+</cell>
+
+<cell type="markdown">
+## 5. Value-representation form — the spectral surface
+
+Every matrix has a dual: **coefficient form** (what `EGPTMatrix.from` produces) and **value-representation form** (samples at integer powers of 2). `EGPTMatrix.toValueReps` converts each row to its sample list via `EGPTPolynomial.toValueRepresentation`; `EGPTMatrix.fromValueReps` inverts via Newton divided differences.
+
+The pair `(toValueReps, fromValueReps)` is an invertible bijection — the same entry C that GEMM produced in coefficient form round-trips through spectral form exactly.
+</cell>
+
+<cell type="js" lane="math" id="value-rep-roundtrip" in="A">
+const { math, display } = caps;
+const { EGPTMatrix } = math;
+const { A } = inputs;
+
+// Convert A to value-rep (spectral) form, then back to coefficient form.
+const A_vr = EGPTMatrix.toValueReps(A);
+const A_rt = EGPTMatrix.fromValueReps(A_vr);
+
+display('A (original coefficient form):');
+display(EGPTMatrix.format(A, 'A'));
+display('A → toValueReps (sample form):');
+display(EGPTMatrix.format(A_vr, 'A_vr'));
+display('A_vr → fromValueReps (recovered coefficient form):');
+display(EGPTMatrix.format(A_rt, 'A_rt'));
+
+const roundTrips = EGPTMatrix.equals(A, A_rt);
+display(`Round-trip exact equality (EGPTMatrix.equals): ${roundTrips ? 'PASS' : 'FAIL'}`);
+if (!roundTrips) throw new Error('Value-rep round-trip failed — EGPTMatrix.equals returned false.');
+</cell>
+
+<cell type="markdown">
+## 6. Transpose
+
+`EGPTMatrix.transpose` swaps rows and columns. For a 2×2 matrix this is straightforward, but the implementation handles arbitrary rectangular shapes. The result is a new matrix; entries are the same `EGPTReal` objects (no copies).
+</cell>
+
+<cell type="js" lane="math" id="transpose" in="B">
+const { math, display } = caps;
+const { EGPTMatrix } = math;
+const { B } = inputs;
+
+const Bt = EGPTMatrix.transpose(B);
+
+display('B:');
+display(EGPTMatrix.format(B, 'B'));
+display('B transposed:');
+display(EGPTMatrix.format(Bt, 'Bᵀ'));
+</cell>
+
+<cell type="markdown">
+## Summary
+
+`EGPTMatrix.gemm` computes the matrix product by routing every dot product through `EGPTPolynomial.multiply` — extracting the (n−1)-th coefficient of the convolution. This is the operational realization of Translation5 (`(Matrix × Matrix) ≃ ℕ × ℕ`): matrix arithmetic **is** polynomial arithmetic in coefficient form, and polynomial arithmetic **is** integer arithmetic via the EGPT bijective chain.
+
+Key methods demonstrated:
+- `EGPTMatrix.from(rows)` — construct from BigInt / integer / EGPTReal entries
+- `EGPTMatrix.gemm(A, B)` — polynomial-routed matrix product (exact rational)
+- `EGPTMatrix.dotViaPolynomial(a, b)` — dot product as polynomial coefficient extraction
+- `EGPTMatrix.toValueReps(M)` / `fromValueReps(VR)` — bijection between coefficient and spectral form
+- `EGPTMatrix.transpose(M)` — row ↔ column swap
+- `EGPTMatrix.equals(A, B)` — exact element-wise comparison
+- `EGPTMatrix.format(M, label)` — render as right-aligned string grid
+- `.toMathString()` on `EGPTReal` entries — exact canonical rational output at the output boundary
+</cell>
+
+</frqtl-notebook>

package/dist/notebooks/notebooks.json

@@ -0,0 +1,240 @@
+{
+  "version": 1,
+  "description": "Curated FRQTL native-notebook index. The BROWSER's list/group index ONLY \u2014 the build copies every lib/notebooks/*.html by directory enumeration (this file never decides what ships). id is the file stem (no .html); ?notebook=<id> round-trips through the presets.js sanitizer charset [a-zA-Z0-9._-].",
+  "notebooks": [
+    {
+      "id": "view-vendored-d3",
+      "file": "view-vendored-d3.html",
+      "title": "View Cell — Vendored d3-array",
+      "group": "Notebook Features"
+    },
+    {
+      "id": "gallery-wave-interference",
+      "file": "gallery-wave-interference.html",
+      "title": "Wave Interference",
+      "group": "Gallery"
+    },
+    {
+      "id": "gallery-double-slit",
+      "file": "gallery-double-slit.html",
+      "title": "Double Slit",
+      "group": "Gallery"
+    },
+    {
+      "id": "gallery-atomic-model",
+      "file": "gallery-atomic-model.html",
+      "title": "Atomic Model",
+      "group": "Gallery"
+    },
+    {
+      "id": "gallery-blackbody",
+      "file": "gallery-blackbody.html",
+      "title": "Blackbody",
+      "group": "Gallery"
+    },
+    {
+      "id": "gallery-big-bang",
+      "file": "gallery-big-bang.html",
+      "title": "Big Bang",
+      "group": "Gallery"
+    },
+    {
+      "id": "gallery-circuit-sat",
+      "file": "gallery-circuit-sat.html",
+      "title": "Circuit SAT",
+      "group": "Gallery"
+    },
+    {
+      "id": "gallery-particle-walk-3d",
+      "file": "gallery-particle-walk-3d.html",
+      "title": "Particle Walk 3D",
+      "group": "Gallery"
+    },
+    {
+      "id": "gallery-collision-matrix-3d",
+      "file": "gallery-collision-matrix-3d.html",
+      "title": "Collision Matrix 3D",
+      "group": "Gallery"
+    },
+    {
+      "id": "gallery-gun-chamber",
+      "file": "gallery-gun-chamber.html",
+      "title": "Gun Chamber",
+      "group": "Gallery"
+    },
+    {
+      "id": "iso-entropy-log",
+      "file": "iso-entropy-log.html",
+      "title": "E \u2014 Entropy-Log Bijection",
+      "group": "Isomorphisms"
+    },
+    {
+      "id": "iso-fft-polynomial",
+      "file": "iso-fft-polynomial.html",
+      "title": "F \u2014 FFT-Polynomial Isomorphism",
+      "group": "Isomorphisms"
+    },
+    {
+      "id": "iso-matrix-four-views",
+      "file": "iso-matrix-four-views.html",
+      "title": "M \u2014 Matrix Four Views",
+      "group": "Isomorphisms"
+    },
+    {
+      "id": "iso-number-theory-four-views",
+      "file": "iso-number-theory-four-views.html",
+      "title": "N \u2014 Number Theory Four Views",
+      "group": "Isomorphisms"
+    },
+    {
+      "id": "iso-canonical-chain",
+      "file": "iso-canonical-chain.html",
+      "title": "U \u2014 Canonical Chain Unified",
+      "group": "Isomorphisms"
+    },
+    {
+      "id": "iso-pi-log-fraction-loop",
+      "file": "iso-pi-log-fraction-loop.html",
+      "title": "\u03c0 \u2014 Log-Fraction Unit Loop",
+      "group": "Isomorphisms"
+    },
+    {
+      "id": "frqtl-qft-benchmark",
+      "file": "frqtl-qft-benchmark.html",
+      "title": "FRQTL QFT Benchmark (vs. supercomputer)",
+      "group": "Showcase"
+    },
+    {
+      "id": "double-slit-rosetta-qft",
+      "file": "double-slit-rosetta-qft.html",
+      "title": "Double Slit \u2192 Rosetta \u2192 QFT",
+      "group": "Showcase"
+    },
+    {
+      "id": "arithmetic-basics",
+      "file": "arithmetic-basics.html",
+      "title": "Arithmetic Basics",
+      "group": "Core Math"
+    },
+    {
+      "id": "factorization-basics",
+      "file": "factorization-basics.html",
+      "title": "Factorization Basics",
+      "group": "Core Math"
+    },
+    {
+      "id": "rational-core",
+      "file": "rational-core.html",
+      "title": "Rational Core",
+      "group": "Core Math"
+    },
+    {
+      "id": "scaled-vectors",
+      "file": "scaled-vectors.html",
+      "title": "Scaled Vectors",
+      "group": "Algebra & Vectors"
+    },
+    {
+      "id": "complex-twiddle",
+      "file": "complex-twiddle.html",
+      "title": "Complex & Twiddle",
+      "group": "Algebra & Vectors"
+    },
+    {
+      "id": "stats",
+      "file": "stats.html",
+      "title": "Statistics",
+      "group": "Statistics"
+    },
+    {
+      "id": "transcendentals",
+      "file": "transcendentals.html",
+      "title": "Transcendentals",
+      "group": "Advanced Math"
+    },
+    {
+      "id": "polynomials",
+      "file": "polynomials.html",
+      "title": "Polynomials",
+      "group": "Advanced Math"
+    },
+    {
+      "id": "fft",
+      "file": "fft.html",
+      "title": "FFT",
+      "group": "Advanced Math"
+    },
+    {
+      "id": "matrix",
+      "file": "matrix.html",
+      "title": "Matrix GEMM",
+      "group": "Advanced Math"
+    },
+    {
+      "id": "prime-composite",
+      "file": "prime-composite.html",
+      "title": "Prime Composite",
+      "group": "Advanced Math"
+    },
+    {
+      "id": "reference-egpt-fft-test",
+      "file": "reference-egpt-fft-test.html",
+      "title": "Reference: FFT Test",
+      "group": "Reference Examples"
+    },
+    {
+      "id": "reference-order-finder-test",
+      "file": "reference-order-finder-test.html",
+      "title": "Reference: Order Finder",
+      "group": "Reference Examples"
+    },
+    {
+      "id": "reference-prime-atom-polynomial-test",
+      "file": "reference-prime-atom-polynomial-test.html",
+      "title": "Reference: Prime-Atom Polynomial",
+      "group": "Reference Examples"
+    },
+    {
+      "id": "reference-solve-polynomial-system-test",
+      "file": "reference-solve-polynomial-system-test.html",
+      "title": "Reference: Solve Polynomial System",
+      "group": "Reference Examples"
+    },
+    {
+      "id": "egpt-test-suite",
+      "file": "egpt-test-suite.html",
+      "title": "EGPT Test Suite",
+      "group": "Original Test Suites"
+    },
+    {
+      "id": "egpt-polynomial-test",
+      "file": "egpt-polynomial-test.html",
+      "title": "Polynomial Test Suite",
+      "group": "Original Test Suites"
+    },
+    {
+      "id": "egpt-fft-test",
+      "file": "egpt-fft-test.html",
+      "title": "FFT Test Suite",
+      "group": "Original Test Suites"
+    },
+    {
+      "id": "egpt-matrix-test",
+      "file": "egpt-matrix-test.html",
+      "title": "Matrix Test Suite",
+      "group": "Original Test Suites"
+    },
+    {
+      "id": "egpt-prime-composite-test",
+      "file": "egpt-prime-composite-test.html",
+      "title": "Prime Composite Test Suite",
+      "group": "Original Test Suites"
+    },
+    {
+      "id": "egpt-topology-test",
+      "file": "egpt-topology-test.html",
+      "title": "Topology Test Suite",
+      "group": "Original Test Suites"
+    }
+  ]
+}

package/dist/notebooks/polynomials.html

@@ -0,0 +1,201 @@
+<frqtl-notebook version="1" title="Polynomial Arithmetic in EGPT Canonical Space">
+
+<cell type="markdown">
+# Polynomial Arithmetic in EGPT Canonical Space
+
+A polynomial over the EGPT number system is just a list of `EGPTReal` coefficients — `[a₀, a₁, a₂, …]` represents `a₀ + a₁x + a₂x²+ …`. All arithmetic stays in exact rational space: no floats, no decimal approximations, no rounding. Coefficients are compared with `.equals()`, never with `==` or `.toString()`.
+
+`EGPTPolynomial` is the static class that provides these operations. Every cell below reaches it through the injected `math` builtin — no imports, no URLs.
+
+The three fundamental operations demonstrated here are:
+
+1. **Addition** — coefficient-wise, extended to match the longer polynomial's degree.
+2. **Multiplication** — convolution (each pair of coefficients multiplied and accumulated at the sum-of-degree position).
+3. **Division** — long division returning an exact `{ quotient, remainder }` pair that satisfies `dividend = divisor × quotient + remainder`.
+</cell>
+
+<cell type="markdown">
+## Setup — construct the two base polynomials
+
+We work with two simple linear polynomials:
+
+- **poly1** = `1 + 2x`
+- **poly2** = `3 + 4x`
+
+Each coefficient is created from an integer via `EGPTReal.fromBigInt(n)`. This places the value in exact rational form (`numerator/denominator` internally) where the denominator is 1.
+</cell>
+
+<cell type="js" lane="math" id="setup" out="poly1, poly2">
+const { math, display } = caps;
+const { EGPTReal } = math;
+
+// poly1 = 1 + 2x  →  coefficients [1, 2] (index = power of x)
+const poly1 = [EGPTReal.fromBigInt(1n), EGPTReal.fromBigInt(2n)];
+
+// poly2 = 3 + 4x  →  coefficients [3, 4]
+const poly2 = [EGPTReal.fromBigInt(3n), EGPTReal.fromBigInt(4n)];
+
+display(`poly1 = ${poly1.map(c => c.toMathString()).join(' + ') /* [1, 2] */}`);
+display(`poly2 = ${poly2.map(c => c.toMathString()).join(' + ') /* [3, 4] */}`);
+display('Coefficients are EGPTReal — exact rationals, no floating-point.');
+
+return { poly1, poly2 };
+</cell>
+
+<cell type="markdown">
+## Addition — `EGPTPolynomial.add(p1, p2)`
+
+Adding two polynomials sums their coefficients position by position. For positions where one polynomial is shorter, the missing coefficient is treated as zero.
+
+Expected result: `(1 + 2x) + (3 + 4x) = 4 + 6x` → coefficients `[4, 6]`.
+</cell>
+
+<cell type="js" lane="math" id="addition" in="poly1, poly2" out="sum">
+const { math, display } = caps;
+const { EGPTPolynomial } = math;
+const { poly1, poly2 } = inputs;
+
+const sum = EGPTPolynomial.add(poly1, poly2);
+
+// Verify: coefficient 0 must be "4", coefficient 1 must be "6"
+if (sum[0].toMathString() !== '4' || sum[1].toMathString() !== '6') {
+  throw new Error('Polynomial addition failed: got ' + sum.map(c => c.toMathString()));
+}
+
+display('poly1 + poly2 = [' + sum.map(c => c.toMathString()).join(', ') + ']');
+display('  = ' + sum[0].toMathString() + ' + ' + sum[1].toMathString() + 'x  ✓');
+
+return { sum };
+</cell>
+
+<cell type="markdown">
+## Multiplication — `EGPTPolynomial.multiply(p1, p2)`
+
+Polynomial multiplication is convolution: the coefficient at degree `k` in the product is the sum of all `a[i] × b[j]` where `i + j = k`.
+
+For `(1 + 2x)(3 + 4x)`:
+
+```
+  degree 0:  1 × 3 = 3
+  degree 1:  1 × 4 + 2 × 3 = 4 + 6 = 10
+  degree 2:  2 × 4 = 8
+```
+
+Expected result: `3 + 10x + 8x²` → coefficients `[3, 10, 8]`.
+</cell>
+
+<cell type="js" lane="math" id="multiplication" in="poly1, poly2" out="product">
+const { math, display } = caps;
+const { EGPTPolynomial } = math;
+const { poly1, poly2 } = inputs;
+
+const product = EGPTPolynomial.multiply(poly1, poly2);
+
+// Verify: [3, 10, 8]
+if (
+  product[0].toMathString() !== '3' ||
+  product[1].toMathString() !== '10' ||
+  product[2].toMathString() !== '8'
+) {
+  throw new Error('Polynomial multiplication failed: got ' + product.map(c => c.toMathString()));
+}
+
+display('poly1 × poly2 = [' + product.map(c => c.toMathString()).join(', ') + ']');
+display('  = ' + product[0].toMathString()
+      + ' + ' + product[1].toMathString() + 'x'
+      + ' + ' + product[2].toMathString() + 'x²  ✓');
+
+return { product };
+</cell>
+
+<cell type="markdown">
+## Division — `EGPTPolynomial.divide(dividend, divisor)`
+
+Polynomial long division works exactly as integer long division, but at each step we divide the leading coefficient of the current remainder by the leading coefficient of the divisor. The result is always an exact rational, so no approximation ever occurs.
+
+`divide()` returns `{ quotient, remainder }` satisfying `dividend = divisor × quotient + remainder`.
+
+We divide the product `3 + 10x + 8x²` back by `poly1 = 1 + 2x`. Since `poly1` is one of the original factors, the quotient should recover `poly2 = 3 + 4x` exactly, with zero remainder.
+</cell>
+
+<cell type="js" lane="math" id="division" in="product, poly1" out="quotient, remainder">
+const { math, display } = caps;
+const { EGPTReal, EGPTPolynomial } = math;
+const { product, poly1 } = inputs;
+
+// dividend = 3 + 10x + 8x²  (the product from the previous cell)
+// divisor  = 1 + 2x           (poly1)
+const dividend = product;
+const divisor  = poly1;
+
+const { quotient, remainder } = EGPTPolynomial.divide(dividend, divisor);
+
+// Verify quotient = [3, 4]
+if (quotient[0].toMathString() !== '3' || quotient[1].toMathString() !== '4') {
+  throw new Error('Polynomial division quotient failed: got ' + quotient.map(c => c.toMathString()));
+}
+
+const zero = EGPTReal.fromBigInt(0n);
+const remIsZero = remainder.every(c => c.equals(zero));
+
+display('dividend ÷ divisor:');
+display('  quotient  = [' + quotient.map(c => c.toMathString()).join(', ') + ']  →  '
+      + quotient[0].toMathString() + ' + ' + quotient[1].toMathString() + 'x');
+display('  remainder = [' + remainder.map(c => c.toMathString()).join(', ') + ']  →  '
+      + (remIsZero ? 'zero (exact division)  ✓' : 'non-zero'));
+display('');
+display('The quotient recovers poly2 exactly — division is the inverse of multiplication in EGPT canonical space.');
+
+return { quotient, remainder };
+</cell>
+
+<cell type="markdown">
+## Summary — all four results
+
+The final cell collects the results and confirms they match the expected values from the source example.
+
+| Operation | Expression | Result (coefficients) |
+|---|---|---|
+| Addition | `(1+2x) + (3+4x)` | `[4, 6]` = `4 + 6x` |
+| Multiplication | `(1+2x) × (3+4x)` | `[3, 10, 8]` = `3 + 10x + 8x²` |
+| Division (quotient) | `(3+10x+8x²) ÷ (1+2x)` | `[3, 4]` = `3 + 4x` |
+| Division (remainder) | — | `[0]` (exact) |
+</cell>
+
+<cell type="js" lane="math" id="summary" in="sum, product, quotient, remainder">
+const { math, display } = caps;
+const { EGPTReal } = math;
+const { sum, product, quotient, remainder } = inputs;
+
+const zero = EGPTReal.fromBigInt(0n);
+const remIsZero = remainder.every(c => c.equals(zero));
+
+const result = {
+  category: 'polynomials',
+  sum:       sum.map(c => c.toMathString()),
+  product:   product.map(c => c.toMathString()),
+  quotient:  quotient.map(c => c.toMathString()),
+  remainder: remainder.map(c => c.toMathString())
+};
+
+const allPass =
+  result.sum[0]     === '4'  && result.sum[1]     === '6'  &&
+  result.product[0] === '3'  && result.product[1] === '10' && result.product[2] === '8' &&
+  result.quotient[0]=== '3'  && result.quotient[1]=== '4'  &&
+  remIsZero;
+
+display(result);
+
+const el = document.createElement('div');
+el.style.cssText =
+  'font:600 0.95rem/1.5 system-ui,sans-serif;padding:10px 14px;border-radius:6px;margin:4px 0;' +
+  (allPass
+    ? 'background:#0f2417;border:1px solid #1f5a36;color:#7ee2a8;'
+    : 'background:#2a0c0c;border:1px solid #5a1f1f;color:#ff8a8a;');
+el.textContent = allPass
+  ? 'ALL CHECKS PASS — polynomial add / multiply / divide verified in exact rational space.'
+  : 'ONE OR MORE CHECKS FAILED — see individual cells for details.';
+display(el);
+</cell>
+
+</frqtl-notebook>