@aleph-ai/tinyaleph 1.5.7 → 1.6.0

package/examples/discrete/04-tick-gate.js

@@ -0,0 +1,139 @@
+/**
+ * Example 04: Tick-Only HQE Gating
+ * 
+ * Demonstrates the tick-based discrete gating from discrete.pdf
+ * where quantum gates activate only on specific tick boundaries.
+ */
+
+const { TickGate } = require('../../apps/sentient/lib/hqe');
+
+console.log('═══════════════════════════════════════════════════════════════');
+console.log('  Tick-Only HQE Gating');
+console.log('═══════════════════════════════════════════════════════════════\n');
+
+// The tick gate concept
+console.log('1. Tick-Based Discrete Gating\n');
+console.log('   From discrete.pdf: Gates activate on discrete tick');
+console.log('   boundaries rather than continuous time.\n');
+console.log('   Benefits:');
+console.log('   • Deterministic gate timing');
+console.log('   • Reduced noise sensitivity');
+console.log('   • Synchronized multi-gate operations');
+console.log('   • Hardware-friendly implementation\n');
+
+// Create tick gates
+console.log('2. Creating Tick Gates\n');
+
+const gates = [
+    new TickGate({ period: 4, phase: 0, name: 'G0' }),
+    new TickGate({ period: 4, phase: 1, name: 'G1' }),
+    new TickGate({ period: 4, phase: 2, name: 'G2' }),
+    new TickGate({ period: 4, phase: 3, name: 'G3' }),
+];
+
+console.log('   Created 4 gates with period=4, different phases:\n');
+for (const gate of gates) {
+    console.log(`   • ${gate.name}: period=${gate.period}, phase=${gate.phase}`);
+}
+
+// Tick simulation
+console.log('\n3. Tick Simulation\n');
+console.log('   Simulating 12 ticks, showing which gates are open:\n');
+
+console.log('   ┌──────┬──────┬──────┬──────┬──────┐');
+console.log('   │ Tick │  G0  │  G1  │  G2  │  G3  │');
+console.log('   ├──────┼──────┼──────┼──────┼──────┤');
+
+for (let tick = 0; tick < 12; tick++) {
+    const states = gates.map(g => g.isOpen(tick) ? '  ●  ' : '  ○  ');
+    console.log(`   │ ${tick.toString().padStart(4)} │${states.join('│')}│`);
+}
+console.log('   └──────┴──────┴──────┴──────┴──────┘');
+
+// Gate application
+console.log('\n4. Gate Application\n');
+
+const inputState = { amplitude: 1.0, phase: 0 };
+const operation = (state) => ({
+    amplitude: state.amplitude * 0.9,
+    phase: state.phase + Math.PI / 4
+});
+
+console.log('   Applying gate operation through tick sequence:\n');
+console.log(`   Input state: amplitude=${inputState.amplitude}, phase=${inputState.phase.toFixed(3)}`);
+
+let currentState = { ...inputState };
+const gate = gates[0];
+
+console.log('\n   ┌──────┬─────────────┬───────────────┬───────────────┐');
+console.log('   │ Tick │ Gate Open?  │ Amplitude     │ Phase         │');
+console.log('   ├──────┼─────────────┼───────────────┼───────────────┤');
+
+for (let tick = 0; tick < 8; tick++) {
+    const open = gate.isOpen(tick);
+    if (open) {
+        currentState = gate.apply(currentState, operation, tick);
+    }
+    const status = open ? 'Yes ●' : 'No  ○';
+    console.log(`   │ ${tick.toString().padStart(4)} │ ${status.padEnd(11)} │ ${currentState.amplitude.toFixed(6).padStart(13)} │ ${currentState.phase.toFixed(6).padStart(13)} │`);
+}
+console.log('   └──────┴─────────────┴───────────────┴───────────────┘');
+
+// Multiple coordinated gates
+console.log('\n5. Coordinated Multi-Gate Operations\n');
+
+console.log('   Multiple gates can be coordinated for complex operations:');
+console.log('   • Sequential: G0 → G1 → G2 → G3');
+console.log('   • Parallel: All gates at same phase');
+console.log('   • Interleaved: Even/odd tick separation\n');
+
+const seqGate = new TickGate({ period: 8, phase: 0, name: 'Prepare' });
+const midGate = new TickGate({ period: 8, phase: 2, name: 'Process' });
+const endGate = new TickGate({ period: 8, phase: 4, name: 'Measure' });
+
+console.log('   Sequential pipeline (period=8):');
+console.log('   ┌──────┬──────────┬──────────┬──────────┐');
+console.log('   │ Tick │ Prepare  │ Process  │ Measure  │');
+console.log('   ├──────┼──────────┼──────────┼──────────┤');
+
+for (let tick = 0; tick < 8; tick++) {
+    const prep = seqGate.isOpen(tick) ? '    ●   ' : '    ○   ';
+    const proc = midGate.isOpen(tick) ? '    ●   ' : '    ○   ';
+    const meas = endGate.isOpen(tick) ? '    ●   ' : '    ○   ';
+    console.log(`   │ ${tick.toString().padStart(4)} │${prep}│${proc}│${meas}│`);
+}
+console.log('   └──────┴──────────┴──────────┴──────────┘');
+
+// Prime-period gates
+console.log('\n6. Prime-Period Gates\n');
+
+console.log('   Using prime periods avoids synchronization artifacts:');
+
+const primeGates = [
+    new TickGate({ period: 3, phase: 0, name: 'P3' }),
+    new TickGate({ period: 5, phase: 0, name: 'P5' }),
+    new TickGate({ period: 7, phase: 0, name: 'P7' }),
+];
+
+console.log('\n   Prime periods (3, 5, 7):');
+console.log('   ┌──────┬──────┬──────┬──────┬─────────────┐');
+console.log('   │ Tick │  P3  │  P5  │  P7  │ All Open    │');
+console.log('   ├──────┼──────┼──────┼──────┼─────────────┤');
+
+for (let tick = 0; tick < 15; tick++) {
+    const p3 = primeGates[0].isOpen(tick);
+    const p5 = primeGates[1].isOpen(tick);
+    const p7 = primeGates[2].isOpen(tick);
+    const allOpen = p3 && p5 && p7 ? 'Yes (LCM=105)' : '';
+    
+    const s3 = p3 ? '  ●  ' : '  ○  ';
+    const s5 = p5 ? '  ●  ' : '  ○  ';
+    const s7 = p7 ? '  ●  ' : '  ○  ';
+    console.log(`   │ ${tick.toString().padStart(4)} │${s3}│${s5}│${s7}│ ${allOpen.padEnd(11)} │`);
+}
+console.log('   └──────┴──────┴──────┴──────┴─────────────┘');
+
+console.log('\n   Prime periods ensure gates rarely align simultaneously,');
+console.log('   reducing interference and providing temporal isolation.');
+
+console.log('\n═══════════════════════════════════════════════════════════════\n');

package/examples/discrete/README.md

@@ -0,0 +1,142 @@
+# Discrete Dynamics Examples
+
+These examples demonstrate the discrete-time dynamics from the discrete.pdf paper for deterministic semantic computation.
+
+## Examples
+
+### [01-integer-sine-table.js](./01-integer-sine-table.js)
+
+Integer sine tables for discrete phase dynamics:
+
+- Pre-computed M=256 sine table
+- Phase accumulator simulation
+- Histogram coherence measurement
+- Phase distribution visualization
+
+```bash
+node examples/discrete/01-integer-sine-table.js
+```
+
+### [02-codebook-tunneling.js](./02-codebook-tunneling.js)
+
+64-attractor codebook and controlled tunneling:
+
+- SMF_CODEBOOK structure (64 attractors)
+- Finding nearest attractor
+- Controlled state transitions
+- Tunneling parameters
+
+```bash
+node examples/discrete/02-codebook-tunneling.js
+```
+
+### [03-canonical-fusion.js](./03-canonical-fusion.js)
+
+Deterministic FUSE(p,q,r) selection:
+
+- Canonical triad ordering
+- Finding triads for target primes
+- Uniqueness guarantee
+- Verification utilities
+
+```bash
+node examples/discrete/03-canonical-fusion.js
+```
+
+### [04-tick-gate.js](./04-tick-gate.js)
+
+Tick-based discrete HQE gating:
+
+- TickGate class usage
+- Coordinated multi-gate operations
+- Sequential pipelines
+- Prime-period isolation
+
+```bash
+node examples/discrete/04-tick-gate.js
+```
+
+## Key Concepts
+
+### Integer Sine Tables
+
+Pre-computed lookup tables for deterministic phase dynamics:
+
+```javascript
+const { INT_SINE_TABLE, computeHistogramCoherence } = require('@aleph-ai/tinyaleph/apps/sentient/lib/prsc');
+
+// Lookup sine value (range -127 to 127)
+const idx = 64;  // 90 degrees
+console.log(INT_SINE_TABLE[idx]);  // 127 (max)
+
+// Compute histogram coherence
+const phases = [0.1, 0.12, 0.11, 0.09, 0.15];
+const coherence = computeHistogramCoherence(phases);
+console.log(coherence.coherence);  // High (phases clustered)
+```
+
+### Codebook Tunneling
+
+64-attractor codebook for controlled state transitions:
+
+```javascript
+const { SMF_CODEBOOK, nearestCodebookAttractor, codebookTunnel } = require('@aleph-ai/tinyaleph/apps/sentient/lib/smf');
+
+// Find nearest attractor
+const state = { s: [1, 0, 0, 0, ...] };
+const nearest = nearestCodebookAttractor(state);
+
+// Controlled tunneling
+const result = codebookTunnel(state, 0.5, 0.3);
+if (result.tunneled) {
+    console.log(`Tunneled to attractor ${result.targetId}`);
+}
+```
+
+### Canonical Fusion
+
+Deterministic triad selection:
+
+```javascript
+const { canonicalFusion, canonicalTriadForTarget } = require('@aleph-ai/tinyaleph/apps/sentient/lib/prime-calculus');
+
+// Get canonical triad for target prime
+const triad = canonicalTriadForTarget(19);
+console.log(triad);  // [3, 5, 11]
+
+// Fuse with automatic canonicalization
+const result = canonicalFusion(11, 3, 5);  // Reordered to (3, 5, 11)
+console.log(result.result);  // 19
+```
+
+### Tick Gates
+
+Discrete-time gate activation:
+
+```javascript
+const { TickGate } = require('@aleph-ai/tinyaleph/apps/sentient/lib/hqe');
+
+const gate = new TickGate({ period: 4, phase: 0 });
+
+for (let tick = 0; tick < 8; tick++) {
+    if (gate.isOpen(tick)) {
+        console.log(`Gate open at tick ${tick}`);
+    }
+}
+```
+
+## Running All Examples
+
+```bash
+# Run all discrete examples
+for f in examples/discrete/*.js; do node "$f"; done
+```
+
+## References
+
+- discrete.pdf: "Discrete Dynamics for Semantic Computation"
+- Section 2: Integer Sine Tables
+- Section 3: Histogram Coherence
+- Section 4: Codebook Tunneling
+- Section 5: Canonical Fusion
+- Section 6: Tick-Only Gating

package/examples/formal-semantics/01-typed-terms.js

@@ -0,0 +1,156 @@
+/**
+ * Example: Typed Terms in Prime-Indexed Semantic Calculi
+ *
+ * Demonstrates the formal type system:
+ * - N(p): Noun terms indexed by prime
+ * - A(p): Adjective/operator terms
+ * - Operator application with p < q constraint
+ * - Triadic fusion FUSE(p,q,r)
+ */
+
+const {
+    N, A, FUSE, CHAIN, SENTENCE, SEQ, IMPL,
+    NounTerm, AdjTerm, ChainTerm, FusionTerm,
+    TypeChecker
+} = require('../../core');
+
+console.log('=== Typed Terms in Prime-Indexed Semantic Calculi ===\n');
+
+// ============================================================================
+// 1. Basic Term Construction
+// ============================================================================
+
+console.log('1. BASIC TERM CONSTRUCTION\n');
+
+// Noun terms - N(p)
+const truth = N(7);      // N(7) - "truth" (semantic meaning)
+const light = N(11);     // N(11) - "light/illumination"
+const wisdom = N(17);    // N(17) - "wisdom"
+
+console.log(`Noun terms:`);
+console.log(`  N(7)  = ${truth.signature()}`);
+console.log(`  N(11) = ${light.signature()}`);
+console.log(`  N(17) = ${wisdom.signature()}`);
+console.log(`  All well-formed: ${truth.isWellFormed() && light.isWellFormed() && wisdom.isWellFormed()}`);
+
+// Adjective terms - A(p)
+const dual = A(2);       // A(2) - "dual" modifier
+const triple = A(3);     // A(3) - "triple" modifier
+const vital = A(5);      // A(5) - "vital" modifier
+
+console.log(`\nAdjective terms:`);
+console.log(`  A(2) = ${dual.signature()}`);
+console.log(`  A(3) = ${triple.signature()}`);
+console.log(`  A(5) = ${vital.signature()}`);
+
+// ============================================================================
+// 2. Operator Application with Ordering Constraint
+// ============================================================================
+
+console.log('\n2. OPERATOR APPLICATION (p < q constraint)\n');
+
+// A(p) can apply to N(q) only if p < q
+console.log(`Can A(3) apply to N(7)? ${triple.canApplyTo(truth)}`);   // true: 3 < 7
+console.log(`Can A(5) apply to N(7)? ${vital.canApplyTo(truth)}`);    // true: 5 < 7
+console.log(`Can A(11) apply to N(7)? ${A(11).canApplyTo(truth)}`);   // false: 11 > 7
+
+// Building operator chains
+const modified = CHAIN([2, 3, 5], N(7));  // A(2)A(3)A(5)N(7)
+console.log(`\nChain: ${modified.toString()}`);
+console.log(`Signature: ${modified.signature()}`);
+console.log(`Well-formed: ${modified.isWellFormed()}`);  // true: all primes < 7
+
+// Ill-formed chain (violates constraint)
+const illFormed = CHAIN([2, 11], N(7));  // A(2)A(11)N(7) - 11 > 7
+console.log(`\nIll-formed chain: ${illFormed.toString()}`);
+console.log(`Well-formed: ${illFormed.isWellFormed()}`);  // false
+
+// ============================================================================
+// 3. Triadic Fusion
+// ============================================================================
+
+console.log('\n3. TRIADIC FUSION - FUSE(p, q, r)\n');
+
+// FUSE(p,q,r) is well-formed when:
+// 1. p, q, r are distinct odd primes
+// 2. p + q + r is prime
+
+const fusion1 = FUSE(3, 5, 11);  // 3 + 5 + 11 = 19 (prime)
+console.log(`FUSE(3, 5, 11):`);
+console.log(`  Signature: ${fusion1.signature()}`);
+console.log(`  Well-formed: ${fusion1.isWellFormed()}`);
+console.log(`  Fused prime: ${fusion1.getFusedPrime()}`);
+
+const fusion2 = FUSE(5, 7, 11);  // 5 + 7 + 11 = 23 (prime)
+console.log(`\nFUSE(5, 7, 11):`);
+console.log(`  Signature: ${fusion2.signature()}`);
+console.log(`  Well-formed: ${fusion2.isWellFormed()}`);
+console.log(`  Fused prime: ${fusion2.getFusedPrime()}`);
+
+// Invalid fusion (sum not prime)
+const invalidFusion = FUSE(2, 3, 5);  // 2 + 3 + 5 = 10 (not prime)
+console.log(`\nFUSE(2, 3, 5):`);
+console.log(`  Well-formed: ${invalidFusion.isWellFormed()}`);  // false
+
+// Find all valid triads for a target prime
+console.log(`\nValid triads for prime 29:`);
+const triads = FusionTerm.findTriads(29);
+triads.slice(0, 5).forEach(t => {
+    console.log(`  ${t.signature()} → ${t.p + t.q + t.r}`);
+});
+
+// ============================================================================
+// 4. Sentence Composition
+// ============================================================================
+
+console.log('\n4. SENTENCE COMPOSITION\n');
+
+// NounSentence - lift noun expression to sentence level
+const s1 = SENTENCE(N(7));      // [N(7)]
+const s2 = SENTENCE(N(11));     // [N(11)]
+
+console.log(`Noun sentences:`);
+console.log(`  S₁ = ${s1.signature()}`);
+console.log(`  S₂ = ${s2.signature()}`);
+
+// Sequential composition: S₁ ◦ S₂
+const seq = SEQ(s1, s2);
+console.log(`\nSequential composition (◦):`);
+console.log(`  S₁ ◦ S₂ = ${seq.signature()}`);
+console.log(`  Discourse state: [${seq.getDiscourseState().join(', ')}]`);
+
+// Implication: S₁ ⇒ S₂
+const impl = IMPL(s1, s2);
+console.log(`\nImplication (⇒):`);
+console.log(`  S₁ ⇒ S₂ = ${impl.signature()}`);
+
+// ============================================================================
+// 5. Type Checking
+// ============================================================================
+
+console.log('\n5. TYPE CHECKING\n');
+
+const checker = new TypeChecker();
+
+// Check various terms
+const terms = [
+    N(7),
+    A(3),
+    CHAIN([2, 3], N(7)),
+    FUSE(3, 5, 11),
+    SENTENCE(N(7))
+];
+
+console.log(`Type inference:`);
+for (const term of terms) {
+    const type = checker.inferType(term);
+    console.log(`  ${term.signature()} : ${type}`);
+}
+
+// Typing judgment derivation
+const judgment = checker.derive(CHAIN([2, 3], N(7)));
+console.log(`\nTyping judgment:`);
+console.log(`  ${judgment.toString()}`);
+console.log(`  Valid: ${judgment.isValid()}`);
+
+console.log('\n=== Done ===');

package/examples/formal-semantics/02-reduction.js

@@ -0,0 +1,202 @@
+/**
+ * Example: Reduction Semantics and Strong Normalization
+ *
+ * Demonstrates the operational semantics:
+ * - Small-step reduction (→)
+ * - Prime-preserving operators (⊕)
+ * - Strong normalization proof
+ * - Confluence via Newman's Lemma
+ * - Fusion canonicalization
+ */
+
+const {
+    N, A, FUSE, CHAIN,
+    ReductionSystem, ResonancePrimeOperator, NextPrimeOperator,
+    isNormalForm, isReducible, termSize,
+    FusionCanonicalizer, NormalFormVerifier,
+    demonstrateStrongNormalization, testLocalConfluence
+} = require('../../core');
+
+console.log('=== Reduction Semantics and Strong Normalization ===\n');
+
+// ============================================================================
+// 1. Prime-Preserving Operators
+// ============================================================================
+
+console.log('1. PRIME-PRESERVING OPERATORS (⊕)\n');
+
+const resonanceOp = new ResonancePrimeOperator();
+const nextPrimeOp = new NextPrimeOperator();
+
+console.log('Operator applicability (p < q required):');
+console.log(`  3 ⊕ 7 applicable: ${resonanceOp.canApply(3, 7)}`);   // true
+console.log(`  7 ⊕ 3 applicable: ${resonanceOp.canApply(7, 3)}`);   // false
+console.log(`  4 ⊕ 7 applicable: ${resonanceOp.canApply(4, 7)}`);   // false (4 not prime)
+
+console.log('\nResonance operator results:');
+console.log(`  3 ⊕ 7 = ${resonanceOp.apply(3, 7)} (via resonance)`);
+console.log(`  5 ⊕ 11 = ${resonanceOp.apply(5, 11)} (via resonance)`);
+console.log(`  7 ⊕ 13 = ${resonanceOp.apply(7, 13)} (via resonance)`);
+
+console.log('\nNext-prime operator results:');
+console.log(`  3 ⊕ 7 = ${nextPrimeOp.apply(3, 7)} (next prime after 7+3)`);
+console.log(`  5 ⊕ 11 = ${nextPrimeOp.apply(5, 11)} (next prime after 11+5)`);
+
+// ============================================================================
+// 2. Normal Form Detection
+// ============================================================================
+
+console.log('\n2. NORMAL FORM DETECTION\n');
+
+const noun = N(7);
+const chain = CHAIN([2, 3], N(7));
+const fusion = FUSE(3, 5, 11);
+
+console.log('Term analysis:');
+console.log(`  N(7) - normal form: ${isNormalForm(noun)}, reducible: ${isReducible(noun)}`);
+console.log(`  A(2)A(3)N(7) - normal form: ${isNormalForm(chain)}, reducible: ${isReducible(chain)}`);
+console.log(`  FUSE(3,5,11) - normal form: ${isNormalForm(fusion)}, reducible: ${isReducible(fusion)}`);
+
+console.log('\nTerm sizes (for termination measure):');
+console.log(`  |N(7)| = ${termSize(noun)}`);
+console.log(`  |A(3)| = ${termSize(A(3))}`);
+console.log(`  |A(2)A(3)N(7)| = ${termSize(chain)}`);
+console.log(`  |FUSE(3,5,11)| = ${termSize(fusion)}`);
+
+// ============================================================================
+// 3. Step-by-Step Reduction
+// ============================================================================
+
+console.log('\n3. STEP-BY-STEP REDUCTION\n');
+
+const reducer = new ReductionSystem();
+
+// Reduce a fusion term
+console.log('Reducing FUSE(3, 5, 11):');
+const fusionStep = reducer.step(fusion);
+console.log(`  ${fusionStep.before} →[${fusionStep.rule}] ${fusionStep.after}`);
+console.log(`  Result: N(${fusionStep.details.sum})`);
+
+// Reduce an operator chain step by step
+console.log('\nReducing A(2)A(3)N(7) step by step:');
+const chainTerm = CHAIN([2, 3], N(7));
+const trace = reducer.normalize(chainTerm);
+
+console.log(`  Initial: ${trace.initial.signature()}`);
+for (let i = 0; i < trace.steps.length; i++) {
+    const step = trace.steps[i];
+    console.log(`  Step ${i+1}: ${step.before.signature()} →[${step.rule}] ${step.after.signature()}`);
+    if (step.details.operator) {
+        console.log(`          (${step.details.operator} ⊕ ${step.details.operand} = ${step.details.result})`);
+    }
+}
+console.log(`  Final: ${trace.final.signature()}`);
+
+// ============================================================================
+// 4. Full Evaluation
+// ============================================================================
+
+console.log('\n4. FULL EVALUATION\n');
+
+const terms = [
+    FUSE(3, 5, 11),
+    CHAIN([2], N(7)),
+    CHAIN([2, 3, 5], N(11)),
+    FUSE(5, 7, 11)
+];
+
+console.log('Evaluating terms to normal form:');
+for (const term of terms) {
+    const result = reducer.evaluate(term);
+    console.log(`  ${term.signature()} →* N(${result.prime})`);
+}
+
+// ============================================================================
+// 5. Strong Normalization Proof
+// ============================================================================
+
+console.log('\n5. STRONG NORMALIZATION (Theorem 1)\n');
+
+console.log('Lemma: If e → e\', then |e\'| < |e|');
+console.log('This ensures termination - no infinite reduction sequences.\n');
+
+const proofTerm = CHAIN([2, 3], N(7));
+const proof = demonstrateStrongNormalization(proofTerm);
+
+console.log(`Term: ${proof.term}`);
+console.log(`Size sequence: [${proof.sizes.join(' > ')}]`);
+console.log(`Strictly decreasing: ${proof.strictlyDecreasing}`);
+console.log(`Normal form: ${proof.normalForm}`);
+console.log(`Verified: ${proof.verified}`);
+
+// ============================================================================
+// 6. Confluence
+// ============================================================================
+
+console.log('\n6. CONFLUENCE (Theorem 2)\n');
+
+console.log('By Newman\'s Lemma: SN + local confluence → confluence');
+console.log('Different reduction orders always reach the same normal form.\n');
+
+const confluenceTest = testLocalConfluence();
+console.log(`All test cases confluent: ${confluenceTest.allConfluent}`);
+for (const tc of confluenceTest.testCases) {
+    console.log(`  ${tc.term} →* ${tc.normalForm}`);
+}
+
+// ============================================================================
+// 7. Fusion Canonicalization
+// ============================================================================
+
+console.log('\n7. FUSION CANONICALIZATION\n');
+
+const canonicalizer = new FusionCanonicalizer();
+
+console.log('Finding canonical triads (d*(P)):');
+const targetPrimes = [19, 23, 29, 31];
+
+for (const P of targetPrimes) {
+    const allTriads = canonicalizer.getTriads(P);
+    const canonical = canonicalizer.selectCanonical(P);
+    
+    if (canonical) {
+        console.log(`  P = ${P}: ${allTriads.length} triads, canonical = FUSE(${canonical.p}, ${canonical.q}, ${canonical.r})`);
+    } else {
+        console.log(`  P = ${P}: no valid triads`);
+    }
+}
+
+// Show scoring
+console.log('\nTriad scoring for P = 23:');
+const triads23 = canonicalizer.getTriads(23);
+for (const t of triads23.slice(0, 3)) {
+    const score = canonicalizer.resonanceScore(t);
+    console.log(`  FUSE(${t.p}, ${t.q}, ${t.r}) - score: ${score.toFixed(4)}`);
+}
+
+// ============================================================================
+// 8. Normal Form Verification
+// ============================================================================
+
+console.log('\n8. NORMAL FORM VERIFICATION (NF_ok)\n');
+
+const verifier = new NormalFormVerifier();
+
+// Correct claims
+console.log('Verifying normal form claims:');
+console.log(`  NF_ok(FUSE(3,5,11), 19): ${verifier.verify(FUSE(3, 5, 11), 19)}`);
+console.log(`  NF_ok(FUSE(5,7,11), 23): ${verifier.verify(FUSE(5, 7, 11), 23)}`);
+
+// Incorrect claims
+console.log(`  NF_ok(FUSE(3,5,11), 17): ${verifier.verify(FUSE(3, 5, 11), 17)}`);  // wrong
+
+// Generate certificate
+console.log('\nVerification certificate:');
+const cert = verifier.certificate(CHAIN([2, 3], N(7)), N(7));
+console.log(`  Term: ${cert.term}`);
+console.log(`  Claimed: ${cert.claimed}`);
+console.log(`  Actual: ${cert.actual}`);
+console.log(`  Verified: ${cert.verified}`);
+console.log(`  Steps: ${cert.steps}`);
+
+console.log('\n=== Done ===');