@descix/egpt-math-sdk 0.1.0

package/dist/notebooks/egpt-topology-test.html

@@ -0,0 +1,410 @@
+<frqtl-notebook version="1" title="Topology-Native Function Tests — sin, cos, exp, and FFT roots from the n-gon">
+
+<cell type="markdown">
+# Topology-Native Function Tests
+
+EGPT mathematics replaces the continuous unit circle with a **discrete n-gon topology**.
+In this model, angles are not measured in radians but as rational *phase fractions*
+where `0` = no rotation, `1/2` = half-rotation (π), and `1` = full rotation (τ = 2π).
+
+The payoff: sin, cos, exp, and the FFT twiddle factors all yield **exact rational values**
+for the canonical rotation points — no floating-point approximation, no transcendental
+constants in the computation. The topology is verified here by showing that
+cos²(φ) + sin²(φ) = 1/2, not 1, for a diagonal phase — the signature of the 8-vertex
+discrete square, not a continuous circle.
+
+Ported from `sdk/egpt-math-sdk/src/editor/tests/EGPTTopologyTestSuite.js`.
+`EGPTReal`, `EGPTMath`, `EGPTranscendental`, `ComplexEGPTReal`, `EGPTComplex` come from
+`caps.math`. The `TestFramework` class is inlined (it is a local helper in the source,
+not part of the SDK surface).
+</cell>
+
+<cell type="markdown">
+## Setup — test harness
+
+A minimal inline `TestFramework` mirrors the one used in the source file.
+Each phase cell receives `suite` and appends its results; the final cell prints
+the overall summary.
+</cell>
+
+<cell type="js" lane="math" id="topo-setup" out="suite">
+const { math } = caps;
+const { EGPTReal, EGPTMath, EGPTranscendental, ComplexEGPTReal, EGPTComplex } = math;
+
+class TestFramework {
+    constructor() {
+        this.tests = [];
+        this.categories = {};
+    }
+    test(description, category, testFunction) {
+        const result = { description, category, passed: false, error: null };
+        try {
+            result.passed = testFunction();
+            if (result.passed === undefined) result.passed = true;
+        } catch (e) {
+            result.passed = false;
+            result.error = e.message;
+        }
+        this.tests.push(result);
+        if (!this.categories[category]) this.categories[category] = [];
+        this.categories[category].push(result);
+        const status = result.passed ? '✅ PASS' : '❌ FAIL';
+        const errMsg = result.error ? ` (${result.error})` : '';
+        console.log(`${status}: ${description}${errMsg}`);
+    }
+    printSummary() {
+        const total = this.tests.length;
+        const passed = this.tests.filter(t => t.passed).length;
+        console.log('='.repeat(60));
+        console.log('TEST SUMMARY');
+        console.log('='.repeat(60));
+        for (const [cat, catTests] of Object.entries(this.categories)) {
+            const p = catTests.filter(t => t.passed).length;
+            console.log(`${cat}: ${p}/${catTests.length} passed`);
+        }
+        console.log('-'.repeat(60));
+        console.log(`TOTAL: ${passed}/${total} tests passed`);
+        console.log(`SUCCESS RATE: ${((passed / total) * 100).toFixed(1)}%`);
+        if (passed < total) {
+            console.log('\n❌ FAILED TESTS:');
+            this.tests.filter(t => !t.passed).forEach(t => {
+                console.log(`   ${t.category}: ${t.description}`);
+                if (t.error) console.log(`      Error: ${t.error}`);
+            });
+        }
+        return { total, passed };
+    }
+}
+
+const test = new TestFramework();
+return { suite: { test, EGPTReal, EGPTMath, EGPTranscendental, ComplexEGPTReal, EGPTComplex } };
+</cell>
+
+<cell type="markdown">
+## Phase T1 — Geometric Constants (Phases)
+
+In the n-gon topology, π and τ are not irrational constants. They are exact rational
+*phase fractions*:
+
+- `PI_PHASE = 1/2` — a half-rotation
+- `TAU_PHASE = 1`  — a full rotation
+
+All trig and exponential work operates on these rational fractions, not on floating-point
+approximations of π.
+</cell>
+
+<cell type="js" lane="math" id="topo-t1" in="suite" out="suite">
+const { test, EGPTReal, EGPTranscendental } = inputs.suite;
+
+console.log('=== PHASE T1: GEOMETRIC CONSTANTS ===');
+
+test.test('EGPTranscendental.PI_PHASE represents a half-rotation (1/2)', 'Geometric Constants', () => {
+    const pi_phase = EGPTranscendental.PI_PHASE;
+    const expected = EGPTReal.fromRational(1n, 2n);
+    return pi_phase.equals(expected);
+});
+
+test.test('EGPTranscendental.TAU_PHASE represents a full-rotation (1)', 'Geometric Constants', () => {
+    const tau_phase = EGPTranscendental.TAU_PHASE;
+    const expected = EGPTReal.fromBigInt(1n);
+    return tau_phase.equals(expected);
+});
+
+return { suite: inputs.suite };
+</cell>
+
+<cell type="markdown">
+## Phase T2 — Topology-Native Trigonometric Functions
+
+Because the phase is rational, the canonical rotation points return exact integers or
+simple fractions — no approximation:
+
+| Phase | Rotation | cos | sin |
+|---|---|---|---|
+| 0 | 0° | 1 | 0 |
+| 1/4 | 90° | 0 | 1 |
+| 1/2 | 180° | −1 | 0 |
+| 1 | 360° | 1 | 0 |
+</cell>
+
+<cell type="js" lane="math" id="topo-t2" in="suite" out="suite">
+const { test, EGPTReal, EGPTMath, EGPTranscendental } = inputs.suite;
+
+console.log('=== PHASE T2: TOPOLOGY-NATIVE TRIGONOMETRY ===');
+
+test.test('cos(0) = 1', 'N-Gon Trigonometry', () => {
+    const phase = EGPTReal.fromBigInt(0n);
+    const result = EGPTranscendental.cos(phase);
+    return result.equals(EGPTReal.fromBigInt(1n));
+});
+
+test.test('sin(0) = 0', 'N-Gon Trigonometry', () => {
+    const phase = EGPTReal.fromBigInt(0n);
+    const result = EGPTranscendental.sin(phase);
+    return result.equals(EGPTReal.fromBigInt(0n));
+});
+
+test.test('cos(PI_PHASE) = -1 (half-rotation)', 'N-Gon Trigonometry', () => {
+    const result = EGPTranscendental.cos(EGPTranscendental.PI_PHASE);
+    return result.equals(EGPTReal.fromBigInt(-1n));
+});
+
+test.test('sin(PI_PHASE) = 0 (half-rotation)', 'N-Gon Trigonometry', () => {
+    const result = EGPTranscendental.sin(EGPTranscendental.PI_PHASE);
+    return result.equals(EGPTReal.fromBigInt(0n));
+});
+
+test.test('cos(PI_PHASE / 2) = 0 (quarter-rotation)', 'N-Gon Trigonometry', () => {
+    const quarter_phase = EGPTMath.divide(EGPTranscendental.PI_PHASE, EGPTReal.fromBigInt(2n));
+    const result = EGPTranscendental.cos(quarter_phase);
+    return result.equals(EGPTReal.fromBigInt(0n));
+});
+
+test.test('sin(PI_PHASE / 2) = 1 (quarter-rotation)', 'N-Gon Trigonometry', () => {
+    const quarter_phase = EGPTMath.divide(EGPTranscendental.PI_PHASE, EGPTReal.fromBigInt(2n));
+    const result = EGPTranscendental.sin(quarter_phase);
+    return result.equals(EGPTReal.fromBigInt(1n));
+});
+
+test.test('cos(TAU_PHASE) = 1 (full-rotation)', 'N-Gon Trigonometry', () => {
+    const result = EGPTranscendental.cos(EGPTranscendental.TAU_PHASE);
+    return result.equals(EGPTReal.fromBigInt(1n));
+});
+
+return { suite: inputs.suite };
+</cell>
+
+<cell type="markdown">
+## Phase T3 — Verifying the N-Gon (Discrete Vertex) Topology
+
+The Pythagorean identity cos²(φ) + sin²(φ) = 1 holds on the **continuous** unit circle.
+On the **discrete** 8-vertex square (phase 1/8 = a diagonal), both cos and sin equal 1/2,
+so their squares sum to 1/4 + 1/4 = **1/2**, not 1.
+
+This is not an approximation error — it is the exact signature of the discrete vertex
+topology. The cell confirms this distinguishing property.
+</cell>
+
+<cell type="js" lane="math" id="topo-t3" in="suite" out="suite">
+const { test, EGPTReal, EGPTMath, EGPTranscendental } = inputs.suite;
+
+console.log('=== PHASE T3: N-GON TOPOLOGY VERIFICATION ===');
+
+test.test('cos²(phase) + sin²(phase) != 1 for diagonal phases', 'N-Gon Topology Verification', () => {
+    // Phase 1/8 is a diagonal on the discrete vertex topology
+    const diagonal_phase = EGPTReal.fromRational(1n, 8n);
+    const cos_val = EGPTranscendental.cos(diagonal_phase); // 1/2 in discrete topology
+    const sin_val = EGPTranscendental.sin(diagonal_phase); // 1/2 in discrete topology
+    const cos_sq = EGPTMath.multiply(cos_val, cos_val);    // 1/4
+    const sin_sq = EGPTMath.multiply(sin_val, sin_val);    // 1/4
+    const sum = EGPTMath.add(cos_sq, sin_sq);              // 1/2 (not 1)
+    const H_one = EGPTReal.fromBigInt(1n);
+    // Sum should be 1/2, confirming the discrete vertex topology
+    return !sum.equals(H_one) && sum.equals(EGPTReal.fromRational(1n, 2n));
+});
+
+test.test('cos(phase 1/8) = 1/2', 'N-Gon Topology Verification', () => {
+    const phase = EGPTReal.fromRational(1n, 8n);
+    const result = EGPTranscendental.cos(phase);
+    return result.equals(EGPTReal.fromRational(1n, 2n));
+});
+
+test.test('sin(phase 1/8) = 1/2', 'N-Gon Topology Verification', () => {
+    const phase = EGPTReal.fromRational(1n, 8n);
+    const result = EGPTranscendental.sin(phase);
+    return result.equals(EGPTReal.fromRational(1n, 2n));
+});
+
+return { suite: inputs.suite };
+</cell>
+
+<cell type="markdown">
+## Phase T4 — Geometric Exponential Function
+
+The complex exponential `exp(a + i·b)` in the n-gon topology:
+
+- Maps imaginary exponent `i·b` to the rotation by phase `b` → exact Euler's identity
+- Acts as a **frequency multiplier**: the output phase is `b × 2^(−a)`
+- Computes exact factorial values for small `n` via direct iteration
+- Provides a Stirling approximation for large `n` using topology-native π and e
+
+Euler's identity becomes `exp(i·PI_PHASE) = −1 + 0i` with exact rational arithmetic —
+no floating-point π involved.
+</cell>
+
+<cell type="js" lane="math" id="topo-t4" in="suite" out="suite">
+const { test, EGPTReal, EGPTMath, EGPTranscendental, ComplexEGPTReal, EGPTComplex } = inputs.suite;
+
+console.log('=== PHASE T4: GEOMETRIC EXPONENTIAL ===');
+
+test.test("exp(i * PI_PHASE) = -1 (Euler's Identity)", 'Geometric Exponential', () => {
+    const H_ZERO = EGPTReal.fromBigInt(0n);
+    const z = new ComplexEGPTReal(H_ZERO, EGPTranscendental.PI_PHASE);
+    const result = EGPTComplex.exp(z);
+    const expected = new ComplexEGPTReal(EGPTReal.fromBigInt(-1n), EGPTReal.fromBigInt(0n));
+    return result.equals(expected);
+});
+
+test.test('exp(i * PI_PHASE / 2) = i (Quarter Turn)', 'Geometric Exponential', () => {
+    const H_ZERO = EGPTReal.fromBigInt(0n);
+    const quarter_phase = EGPTMath.divide(EGPTranscendental.PI_PHASE, EGPTReal.fromBigInt(2n));
+    const z = new ComplexEGPTReal(H_ZERO, quarter_phase);
+    const result = EGPTComplex.exp(z);
+    const expected = new ComplexEGPTReal(EGPTReal.fromBigInt(0n), EGPTReal.fromBigInt(1n));
+    return result.equals(expected);
+});
+
+test.test('Unit Circle Identity: |exp(z)| == 1 (L1 norm)', 'Geometric Exponential', () => {
+    // a=2, b=1/8: in the discrete topology the L1 magnitude is |x|+|y|
+    const z = new ComplexEGPTReal(EGPTReal.fromBigInt(2n), EGPTReal.fromRational(1n, 8n));
+    const result = EGPTComplex.exp(z);
+    const abs_x = EGPTMath.abs(result.real);
+    const abs_y = EGPTMath.abs(result.imag);
+    const magnitude = EGPTMath.add(abs_x, abs_y);
+    return magnitude.equals(EGPTReal.fromBigInt(1n));
+});
+
+test.test('exp(a) acts as frequency multiplier 2^-a', 'Geometric Exponential', () => {
+    const H_a = EGPTReal.fromBigInt(1n);
+    const H_b = EGPTReal.fromRational(1n, 8n);
+    const z = new ComplexEGPTReal(H_a, H_b);
+    const result = EGPTComplex.exp(z);
+    const result_phase = result.getPhase();
+    // Expected phase = b * 2^(-a) = (1/8) * (1/2) = 1/16
+    const H_neg_a = EGPTReal.negate(H_a);
+    const H_freq_multiplier = EGPTranscendental.exp2(H_neg_a);
+    const H_expected_phase = EGPTMath.normalMultiply(H_b, H_freq_multiplier);
+    return result_phase.equals(H_expected_phase);
+});
+
+test.test('Factorial computation: 5! = 120 using topology-native operations', 'Geometric Exponential', () => {
+    const n = 5n;
+    const H_result = EGPTranscendental.factorial(n);
+    const H_expected = EGPTReal.fromBigInt(120n);
+    return EGPTMath.equals(H_result, H_expected);
+});
+
+test.test("Factorial Stirling approximation: 97! computed via topology-native formula", 'Geometric Exponential', () => {
+    // Compute 97! exactly via iterative multiplication
+    const n = 97n;
+    let en_97_factorial = EGPTReal.fromBigInt(1n);
+    for (let i = 2n; i <= n; i++) {
+        en_97_factorial = EGPTMath.multiply(en_97_factorial, EGPTReal.fromBigInt(i));
+    }
+    // Compute via Stirling's approximation
+    const H_stirling_result = EGPTranscendental.factorial(n);
+    // Compare: relative error = |exact - approx| / exact
+    const H_diff = EGPTMath.subtract(en_97_factorial, H_stirling_result);
+    const H_abs_diff = EGPTMath.abs(H_diff);
+    const H_relative_error = EGPTMath.normalDivide(H_abs_diff, en_97_factorial);
+    const relative_error = H_relative_error.breakSymbolicToApproximateJSNumber();
+    console.log(`      97! (Stirling) relative error: ${isFinite(relative_error) ? (relative_error * 100).toFixed(4) + '%' : 'Infinity (scaled vector — see note)'}`);
+    return relative_error < 0.01;
+});
+
+return { suite: inputs.suite };
+</cell>
+
+<cell type="markdown">
+## Phase T5 — FFT / FAT Foundational Elements
+
+The Discrete Fourier Transform uses **roots of unity** ω_N^k = exp(i · 2π · k/N).
+In the n-gon topology, these are `EGPTComplex.exp(0 + i · TAU_PHASE · (k/N))` and
+evaluate to exact rational complex numbers at every lattice point.
+
+Key properties verified:
+- **ω_N^0 = 1** for any N (identity)
+- **ω_N^N = 1** (full-period periodicity)
+- **ω_N^k and ω_N^(N−k) are conjugates** (symmetry that halves real FFT work)
+- **DC component** X[0] = Σ x[n] (sum of all inputs)
+- **Unnormalized inverse** of normalized = N × original
+</cell>
+
+<cell type="js" lane="math" id="topo-t5" in="suite" out="suite">
+const { test, EGPTReal, EGPTMath, EGPTranscendental, ComplexEGPTReal, EGPTComplex } = inputs.suite;
+
+console.log('=== PHASE T5: FFT FOUNDATIONAL ELEMENTS ===');
+
+test.test('Roots of unity: ω_N^0 = 1 for any N', 'FFT Foundations', () => {
+    const N = 8;
+    const phase = EGPTReal.fromRational(0n, BigInt(N));
+    const root = EGPTComplex.exp(new ComplexEGPTReal(
+        EGPTReal.fromBigInt(0n),
+        EGPTMath.multiply(EGPTranscendental.TAU_PHASE, phase)
+    ));
+    const one = new ComplexEGPTReal(EGPTReal.fromBigInt(1n), EGPTReal.fromBigInt(0n));
+    return root.equals(one);
+});
+
+test.test('Roots of unity: ω_N^N = 1 (periodicity)', 'FFT Foundations', () => {
+    const N = 8;
+    const phase = EGPTReal.fromRational(BigInt(N), BigInt(N)); // full rotation = 1
+    const root = EGPTComplex.exp(new ComplexEGPTReal(
+        EGPTReal.fromBigInt(0n),
+        EGPTMath.multiply(EGPTranscendental.TAU_PHASE, phase)
+    ));
+    const one = new ComplexEGPTReal(EGPTReal.fromBigInt(1n), EGPTReal.fromBigInt(0n));
+    return root.equals(one);
+});
+
+test.test('Roots of unity: ω_N^k and ω_N^(N-k) are conjugates', 'FFT Foundations', () => {
+    const N = 8, k = 2;
+    const phase_k  = EGPTReal.fromRational(BigInt(k), BigInt(N));
+    const phase_Nk = EGPTReal.fromRational(BigInt(N - k), BigInt(N));
+    const root_k  = EGPTComplex.exp(new ComplexEGPTReal(
+        EGPTReal.fromBigInt(0n),
+        EGPTMath.multiply(EGPTranscendental.TAU_PHASE, phase_k)
+    ));
+    const root_Nk = EGPTComplex.exp(new ComplexEGPTReal(
+        EGPTReal.fromBigInt(0n),
+        EGPTMath.multiply(EGPTranscendental.TAU_PHASE, phase_Nk)
+    ));
+    return root_k.conjugate().equals(root_Nk);
+});
+
+test.test('Forward FFT: DC component = sum of all inputs', 'FFT Foundations', () => {
+    // X[0] = Σ x[n] for n = 0 to N-1; signal = [1, 2, 3, 4]
+    const N = 4;
+    const signal = [];
+    for (let i = 0; i < N; i++) {
+        signal.push(new ComplexEGPTReal(EGPTReal.fromBigInt(BigInt(i + 1)), EGPTReal.fromBigInt(0n)));
+    }
+    let sum = EGPTReal.fromBigInt(0n);
+    for (const s of signal) { sum = EGPTMath.add(sum, s.real); }
+    return sum.equals(EGPTReal.fromBigInt(10n)); // 1+2+3+4 = 10
+});
+
+test.test('Inverse FFT normalization: unnormalized result = N * original', 'FFT Foundations', () => {
+    // IEQFT without normalization: N * original
+    const N = 4;
+    const scale = EGPTReal.fromBigInt(BigInt(N));
+    const original = EGPTReal.fromBigInt(5n);
+    const scaled = EGPTMath.multiply(original, scale);
+    return scaled.equals(EGPTReal.fromBigInt(20n)); // 4 * 5 = 20
+});
+
+return { suite: inputs.suite };
+</cell>
+
+<cell type="markdown">
+## Summary
+
+The final cell accumulates results from all phases and prints the suite totals.
+</cell>
+
+<cell type="js" lane="math" id="topo-summary" in="suite">
+const { test } = inputs.suite;
+
+console.log('\n' + '='.repeat(60));
+const { total, passed } = test.printSummary();
+console.log('='.repeat(60));
+
+const failed = total - passed;
+if (failed === 0) {
+    console.log('All topology-native functions validated.');
+} else {
+    console.log(`${failed} test(s) failed — see FAILED TESTS list above.`);
+}
+</cell>
+
+</frqtl-notebook>

package/dist/notebooks/factorization-basics.html

@@ -0,0 +1,131 @@
+<frqtl-notebook version="1" title="Factorization Basics — How EGPTReal Encodes Integers as Prime-Factor Vectors">
+
+<cell type="markdown">
+# Factorization Basics — How EGPTReal Encodes Integers as Prime-Factor Vectors
+
+Every integer has a unique factorization into prime powers — the Fundamental Theorem of Arithmetic. EGPT makes this canonical: `EGPTReal.fromBigInt(n)` does not store `n` as a single integer; it encodes `n` as a **PPF (Prime-Power Factorization) vector**, where each dimension corresponds to one prime and the coordinate is that prime's exponent.
+
+This is the foundation of every EGPT operation. Multiplication becomes vector addition, division becomes vector subtraction, and equality becomes exact component-wise comparison — no floating-point, no rounding, no approximation.
+
+This notebook demonstrates that encoding on three representative integers: a composite with small factors (12), a power of two (64), and a prime (97).
+
+Every computation runs through the injected `math` builtin. No URLs are imported; the live math backend is reported by the SDK itself.
+</cell>
+
+<cell type="js" lane="math" id="backend">
+// Report the active math backend — DERIVED from the SDK, never asserted.
+const { math, display } = caps;
+const backend = math.activeMathBackend;
+display(`Active math backend (derived from MathBackendRegistry): ${backend}`);
+</cell>
+
+<cell type="markdown">
+## 1. What is a PPF vector?
+
+For a positive integer `n`, its **prime-power factorization** is the product:
+
+```
+n = p1^e1 × p2^e2 × p3^e3 × …
+```
+
+where `p1 < p2 < p3 < …` are the distinct prime factors of `n` and each `e_k ≥ 1`.
+
+`EGPTReal` stores this as a **lossless rational vector in log₂-space**: each prime factor becomes a coordinate so that multiplication is vector addition (the RET Iron Law: `H(a × b) = H(a) + H(b)`). The `toMathString()` method reads back the canonical rational form of the PPF-encoded value.
+
+The three examples below cover all structurally distinct cases:
+
+| Integer | Structure | Expected PPF |
+|---------|-----------|--------------|
+| **12** | `2² × 3¹` | composite, two distinct primes |
+| **64** | `2⁶` | pure power of 2 |
+| **97** | `97¹` | prime — only one factor, exponent = 1 |
+</cell>
+
+<cell type="js" lane="math" id="encode-12" out="r12">
+// EGPTReal.fromBigInt(n) encodes n as a PPF vector.
+// toMathString() returns the canonical rational form of that vector.
+// For integers, this matches the original value — demonstrating lossless encoding.
+const { math, display } = caps;
+const { EGPTReal } = math;
+
+const n = 12n;
+const encoded = EGPTReal.fromBigInt(n);
+const ppf = encoded.toMathString();
+display(`EGPTReal.fromBigInt(12n).toMathString() → "${ppf}"`);
+
+const r12 = { value: n.toString(), ppf };
+return { r12 };
+</cell>
+
+<cell type="markdown">
+## 2. A power of two — the simplest non-trivial case
+
+`64 = 2⁶`. There is only one prime involved, so the PPF vector has a single non-zero coordinate (the exponent of 2). This is the degenerate case that binary arithmetic handles natively, but EGPT's PPF encoding handles it identically to any other integer — no special path.
+</cell>
+
+<cell type="js" lane="math" id="encode-64" out="r64">
+const { math, display } = caps;
+const { EGPTReal } = math;
+
+const n = 64n;
+const encoded = EGPTReal.fromBigInt(n);
+const ppf = encoded.toMathString();
+display(`EGPTReal.fromBigInt(64n).toMathString() → "${ppf}"`);
+
+const r64 = { value: n.toString(), ppf };
+return { r64 };
+</cell>
+
+<cell type="markdown">
+## 3. A prime — only one atom, exponent exactly 1
+
+`97` is prime, so its PPF vector has exactly one non-zero coordinate: exponent `1` at position `97`. This is the structural opposite of a composite: no reduction to smaller primes is possible, and the PPF encodes the integer exactly as-is.
+
+Primes are the "atoms" of the PPF representation — the 0-dimensional coordinates with no further decomposition.
+</cell>
+
+<cell type="js" lane="math" id="encode-97" out="r97">
+const { math, display } = caps;
+const { EGPTReal } = math;
+
+const n = 97n;
+const encoded = EGPTReal.fromBigInt(n);
+const ppf = encoded.toMathString();
+display(`EGPTReal.fromBigInt(97n).toMathString() → "${ppf}"`);
+
+const r97 = { value: n.toString(), ppf };
+return { r97 };
+</cell>
+
+<cell type="markdown">
+## 4. Summary — canonical PPF normalization
+
+All three cases above confirm that `EGPTReal.fromBigInt(n).toMathString()` returns a canonical rational form that represents `n` exactly. The cell below assembles the results from the three encoding cells into a single summary table, matching the original `factorization-basics` demo's output contract.
+</cell>
+
+<cell type="js" lane="math" id="summary" in="r12, r64, r97">
+const { display } = caps;
+const checks = [inputs.r12, inputs.r64, inputs.r97];
+
+const lines = [
+  'category: factorization-basics',
+  'note: Shows canonical EGPTReal normalization for representative integers.',
+  '',
+  'value   | ppf (canonical toMathString)',
+  '--------|-----------------------------'
+];
+for (const c of checks) {
+  lines.push(`${c.value.padEnd(7)} | ${c.ppf}`);
+}
+display(lines.join('\n'));
+
+return {
+  result: {
+    category: 'factorization-basics',
+    checks,
+    note: 'Shows canonical EGPTReal normalization for representative integers.'
+  }
+};
+</cell>
+
+</frqtl-notebook>