@aleph-ai/tinyaleph 1.5.7 → 1.6.0

package/examples/scientific/04-measurement.js

@@ -0,0 +1,229 @@
+/**
+ * @example Quantum Measurement
+ * @description Explore quantum measurement and state collapse
+ * 
+ * Measurement in quantum mechanics:
+ * - Collapses superposition to definite state
+ * - Results are probabilistic
+ * - Cannot be undone
+ */
+
+const { ScientificBackend, Hypercomplex } = require('../../modular');
+
+// ===========================================
+// SETUP
+// ===========================================
+
+const backend = new ScientificBackend({ dimension: 4 });
+
+console.log('TinyAleph Quantum Measurement Example');
+console.log('=====================================\n');
+
+// ===========================================
+// MEASUREMENT BASICS
+// ===========================================
+
+console.log('Measurement Basics:');
+console.log('-'.repeat(50) + '\n');
+
+console.log('Before measurement: |ψ⟩ = α|0⟩ + β|1⟩');
+console.log('After measurement: |0⟩ or |1⟩ (definite state)');
+console.log('Probability: P(0) = |α|², P(1) = |β|²\n');
+
+// Create superposition
+var ket0 = backend.encode('|0⟩');
+var superposition = backend.applyGate(ket0, 'H');
+var state = backend.primesToState(superposition);
+
+console.log('Superposition state |+⟩:');
+console.log('  Components: [' + state.c.slice(0, 2).map(function(v) { return v.toFixed(4); }).join(', ') + ']');
+console.log('  Norm: ' + state.norm().toFixed(4) + '\n');
+
+// ===========================================
+// REPEATED MEASUREMENTS
+// ===========================================
+
+console.log('='.repeat(50));
+console.log('Repeated Measurements:');
+console.log('='.repeat(50) + '\n');
+
+function runMeasurements(trials, prepareState) {
+    var results = {};
+    
+    for (var i = 0; i < trials; i++) {
+        var state = prepareState();
+        var result = backend.measure(state);
+        results[result] = (results[result] || 0) + 1;
+    }
+    
+    return results;
+}
+
+// Equal superposition
+console.log('Measuring |+⟩ = (|0⟩ + |1⟩)/√2:\n');
+
+var equalResults = runMeasurements(1000, function() {
+    var primes = backend.applyGate(ket0, 'H');
+    return backend.primesToState(primes);
+});
+
+for (var result in equalResults) {
+    if (equalResults.hasOwnProperty(result)) {
+        var count = equalResults[result];
+        var pct = (count / 1000 * 100).toFixed(1);
+        console.log('  |' + result + '⟩: ' + count + ' (' + pct + '%)');
+    }
+}
+console.log('  Expected: ~50% each\n');
+
+// ===========================================
+// BIASED SUPERPOSITION
+// ===========================================
+
+console.log('='.repeat(50));
+console.log('Biased Superpositions:');
+console.log('='.repeat(50) + '\n');
+
+console.log('States with unequal amplitudes have biased probabilities.\n');
+
+// Simulate biased state (|ψ⟩ = √0.8|0⟩ + √0.2|1⟩)
+function simulateBiasedMeasurement(prob0) {
+    return Math.random() < prob0 ? '0' : '1';
+}
+
+var biasedResults = { '0': 0, '1': 0 };
+var trials = 1000;
+var prob0 = 0.8;
+
+for (var i = 0; i < trials; i++) {
+    var result = simulateBiasedMeasurement(prob0);
+    biasedResults[result]++;
+}
+
+console.log('Measuring |ψ⟩ = √0.8|0⟩ + √0.2|1⟩:\n');
+console.log('  |0⟩: ' + biasedResults['0'] + ' (' + (biasedResults['0']/trials*100).toFixed(1) + '%)');
+console.log('  |1⟩: ' + biasedResults['1'] + ' (' + (biasedResults['1']/trials*100).toFixed(1) + '%)');
+console.log('  Expected: ~80% |0⟩, ~20% |1⟩');
+
+// ===========================================
+// MEASUREMENT COLLAPSE
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Measurement Collapse:');
+console.log('='.repeat(50) + '\n');
+
+console.log('After measurement, the state is collapsed.');
+console.log('Repeated measurements of the SAME state give SAME result.\n');
+
+// Demonstrate collapse
+var collapsedState = null;
+var firstMeasurement = null;
+var subsequentResults = [];
+
+// First measurement collapses the state
+for (var i = 0; i < 10; i++) {
+    if (i === 0) {
+        var primes = backend.applyGate(ket0, 'H');
+        collapsedState = backend.primesToState(primes);
+        firstMeasurement = backend.measure(collapsedState);
+        subsequentResults.push(firstMeasurement);
+    } else {
+        // After collapse, measurement is deterministic
+        subsequentResults.push(firstMeasurement);
+    }
+}
+
+console.log('Initial measurement: |' + firstMeasurement + '⟩');
+console.log('Subsequent measurements (same collapsed state):');
+console.log('  ' + subsequentResults.join(', '));
+console.log('  All same (state is collapsed)');
+
+// ===========================================
+// MULTI-QUBIT MEASUREMENT
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Multi-Qubit Measurement:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Measuring multiple qubits:');
+console.log('  Can measure all at once or sequentially');
+console.log('  Entangled qubits show correlations\n');
+
+// Simulate Bell state measurement
+var bellResults = { '00': 0, '01': 0, '10': 0, '11': 0 };
+trials = 1000;
+
+for (var i = 0; i < trials; i++) {
+    // Bell state has 50% |00⟩ and 50% |11⟩
+    var r = Math.random();
+    if (r < 0.5) {
+        bellResults['00']++;
+    } else {
+        bellResults['11']++;
+    }
+}
+
+console.log('Measuring Bell state |Φ+⟩ = (|00⟩ + |11⟩)/√2:\n');
+for (var outcome in bellResults) {
+    if (bellResults.hasOwnProperty(outcome)) {
+        var count = bellResults[outcome];
+        console.log('  |' + outcome + '⟩: ' + count + ' (' + (count/trials*100).toFixed(1) + '%)');
+    }
+}
+console.log('  Note: |01⟩ and |10⟩ never occur (entanglement)');
+
+// ===========================================
+// MEASUREMENT STATISTICS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Measurement Statistics:');
+console.log('='.repeat(50) + '\n');
+
+function computeStatistics(results, total) {
+    var stats = {};
+    
+    for (var outcome in results) {
+        if (results.hasOwnProperty(outcome)) {
+            var count = results[outcome];
+            var frequency = count / total;
+            var stdError = Math.sqrt(frequency * (1 - frequency) / total);
+            
+            stats[outcome] = {
+                count: count,
+                frequency: frequency,
+                stdError: stdError
+            };
+        }
+    }
+    
+    return stats;
+}
+
+var stats = computeStatistics(equalResults, 1000);
+
+console.log('Statistical analysis of equal superposition:\n');
+for (var outcome in stats) {
+    if (stats.hasOwnProperty(outcome)) {
+        var s = stats[outcome];
+        console.log('  |' + outcome + '⟩:');
+        console.log('    Frequency: ' + (s.frequency * 100).toFixed(2) + '%');
+        console.log('    Standard Error: ' + (s.stdError * 100).toFixed(2) + '%');
+        console.log('    95% CI: [' + ((s.frequency - 1.96*s.stdError)*100).toFixed(1) + '%, ' + ((s.frequency + 1.96*s.stdError)*100).toFixed(1) + '%]');
+    }
+}
+
+// ===========================================
+// KEY TAKEAWAYS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('KEY TAKEAWAYS:');
+console.log('1. Measurement collapses superposition');
+console.log('2. Results are probabilistic (|amplitude|²)');
+console.log('3. Collapsed states give deterministic results');
+console.log('4. Entangled qubits show correlated outcomes');
+console.log('5. Statistical analysis quantifies uncertainty');
+console.log('6. Cannot predict individual measurement outcomes');

package/examples/scientific/05-algorithms.js

@@ -0,0 +1,245 @@
+/**
+ * @example Quantum Algorithms
+ * @description Implement basic quantum algorithms
+ * 
+ * Famous quantum algorithms that demonstrate quantum advantage:
+ * - Deutsch-Jozsa: Determines function properties
+ * - Grover: Searches unstructured data
+ * - Quantum Teleportation: Transfers quantum states
+ */
+
+const { ScientificBackend, Hypercomplex } = require('../../modular');
+
+// ===========================================
+// SETUP
+// ===========================================
+
+const backend = new ScientificBackend({ dimension: 8 });
+
+console.log('TinyAleph Quantum Algorithms Example');
+console.log('====================================\n');
+
+// ===========================================
+// DEUTSCH-JOZSA ALGORITHM
+// ===========================================
+
+console.log('Deutsch-Jozsa Algorithm:');
+console.log('-'.repeat(50) + '\n');
+
+console.log('Problem: Given f(x), determine if it is:');
+console.log('  - Constant: f(x) = 0 for all x, or f(x) = 1 for all x');
+console.log('  - Balanced: f(x) = 0 for half, f(x) = 1 for half\n');
+
+console.log('Classical: Need up to 2^(n-1) + 1 queries');
+console.log('Quantum: Need exactly 1 query!\n');
+
+function deutschJozsa(oracle) {
+    // Simplified simulation of Deutsch-Jozsa
+    // In full implementation, we'd apply H gates, oracle, H gates, measure
+    
+    var steps = [
+        'Initialize |0...0⟩|1⟩',
+        'Apply H to all qubits',
+        'Apply oracle U_f',
+        'Apply H to input qubits',
+        'Measure input qubits'
+    ];
+    
+    console.log('Algorithm steps:');
+    for (var i = 0; i < steps.length; i++) {
+        console.log('  ' + (i + 1) + '. ' + steps[i]);
+    }
+    
+    // Simulate result based on oracle type
+    var result = oracle.type === 'constant' ? '000' : '001'; // Non-zero means balanced
+    
+    return {
+        measurement: result,
+        conclusion: result === '000' ? 'Constant' : 'Balanced',
+        queries: 1
+    };
+}
+
+// Test with constant and balanced oracles
+var constantOracle = { type: 'constant', f: function(x) { return 0; } };
+var balancedOracle = { type: 'balanced', f: function(x) { return x % 2; } };
+
+console.log('\nConstant function (f(x) = 0):');
+var result1 = deutschJozsa(constantOracle);
+console.log('  Measurement: |' + result1.measurement + '⟩');
+console.log('  Conclusion: ' + result1.conclusion);
+console.log('  Queries used: ' + result1.queries);
+
+console.log('\nBalanced function (f(x) = x mod 2):');
+var result2 = deutschJozsa(balancedOracle);
+console.log('  Measurement: |' + result2.measurement + '⟩');
+console.log('  Conclusion: ' + result2.conclusion);
+console.log('  Queries used: ' + result2.queries);
+
+// ===========================================
+// GROVER'S SEARCH ALGORITHM
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log("Grover's Search Algorithm:");
+console.log('='.repeat(50) + '\n');
+
+console.log('Problem: Find a marked item in an unstructured database');
+console.log('Classical: O(N) queries needed');
+console.log('Quantum: O(√N) queries needed!\n');
+
+function groverSearch(databaseSize, markedItem) {
+    var n = Math.ceil(Math.log2(databaseSize));
+    var iterations = Math.floor(Math.PI / 4 * Math.sqrt(databaseSize));
+    
+    console.log('Database size: ' + databaseSize);
+    console.log('Qubits needed: ' + n);
+    console.log('Grover iterations: ' + iterations);
+    
+    // Simulate Grover steps
+    var steps = [
+        'Initialize: |s⟩ = H⊗n|0⟩ (equal superposition)',
+        'Repeat ' + iterations + ' times:',
+        '  a. Apply oracle O_f (phase flip marked item)',
+        '  b. Apply diffusion operator D',
+        'Measure'
+    ];
+    
+    console.log('\nAlgorithm:');
+    for (var i = 0; i < steps.length; i++) {
+        console.log('  ' + steps[i]);
+    }
+    
+    // Probability of finding marked item
+    var successProb = Math.sin((2 * iterations + 1) * Math.asin(1 / Math.sqrt(databaseSize))) ** 2;
+    
+    return {
+        markedItem: markedItem,
+        iterations: iterations,
+        successProbability: successProb,
+        classicalQueries: databaseSize / 2
+    };
+}
+
+var groverResult = groverSearch(16, 7);
+console.log('\nResult:');
+console.log('  Looking for item: ' + groverResult.markedItem);
+console.log('  Success probability: ' + (groverResult.successProbability * 100).toFixed(1) + '%');
+console.log('  Quantum queries: ' + groverResult.iterations);
+console.log('  Classical average: ' + groverResult.classicalQueries);
+console.log('  Speedup: ' + (groverResult.classicalQueries / groverResult.iterations).toFixed(1) + 'x');
+
+// ===========================================
+// QUANTUM TELEPORTATION
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Quantum Teleportation:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Transfer quantum state |ψ⟩ using entanglement and classical bits.\n');
+
+function teleportation(inputState) {
+    console.log('Protocol:');
+    console.log('  1. Alice and Bob share Bell pair |Φ+⟩');
+    console.log('  2. Alice has state to teleport: ' + inputState);
+    console.log('  3. Alice performs Bell measurement on her qubits');
+    console.log('  4. Alice sends 2 classical bits to Bob');
+    console.log('  5. Bob applies correction based on classical bits');
+    console.log('  6. Bob recovers ' + inputState + '\n');
+    
+    // Simulate teleportation
+    var measurementOutcomes = ['00', '01', '10', '11'];
+    var outcome = measurementOutcomes[Math.floor(Math.random() * 4)];
+    
+    var corrections = {
+        '00': 'None (I)',
+        '01': 'X gate',
+        '10': 'Z gate',
+        '11': 'Z then X gates'
+    };
+    
+    return {
+        inputState: inputState,
+        bellMeasurement: outcome,
+        correction: corrections[outcome],
+        outputState: inputState,
+        success: true
+    };
+}
+
+var teleResult = teleportation('α|0⟩ + β|1⟩');
+console.log('Simulation:');
+console.log('  Input state: ' + teleResult.inputState);
+console.log('  Bell measurement: |' + teleResult.bellMeasurement + '⟩');
+console.log('  Bob applies: ' + teleResult.correction);
+console.log('  Output state: ' + teleResult.outputState);
+console.log('  Teleportation successful: ' + teleResult.success);
+
+// ===========================================
+// QUANTUM PHASE ESTIMATION
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Quantum Phase Estimation:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Estimates the phase θ of a unitary U where U|ψ⟩ = e^(2πiθ)|ψ⟩');
+console.log('Key subroutine for many quantum algorithms.\n');
+
+function phaseEstimation(truePhase, precision) {
+    var n = precision;
+    
+    console.log('True phase: ' + truePhase);
+    console.log('Precision bits: ' + n);
+    console.log('Phase resolution: 1/' + Math.pow(2, n) + ' = ' + (1/Math.pow(2, n)).toFixed(4));
+    
+    // Simulate phase estimation
+    // In real algorithm: controlled-U gates, inverse QFT, measure
+    
+    var estimatedBinary = Math.round(truePhase * Math.pow(2, n));
+    var estimatedPhase = estimatedBinary / Math.pow(2, n);
+    var error = Math.abs(truePhase - estimatedPhase);
+    
+    return {
+        truePhase: truePhase,
+        estimatedPhase: estimatedPhase,
+        error: error,
+        precision: n
+    };
+}
+
+var qpe = phaseEstimation(0.375, 4);
+console.log('\nResult:');
+console.log('  True phase: ' + qpe.truePhase);
+console.log('  Estimated: ' + qpe.estimatedPhase);
+console.log('  Error: ' + qpe.error);
+
+// ===========================================
+// ALGORITHM COMPARISON
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Algorithm Comparison:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Algorithm            Problem                Classical  Quantum');
+console.log('-'.repeat(70));
+console.log('Deutsch-Jozsa        Function type          O(2^n)     O(1)');
+console.log('Grover               Search                 O(N)       O(√N)');
+console.log('Shor                 Factoring              O(exp)     O((log N)³)');
+console.log('Phase Estimation     Eigenvalue             O(poly)    O(log(1/ε))');
+console.log('Teleportation        State transfer         N/A        O(1) + 2 bits');
+
+// ===========================================
+// KEY TAKEAWAYS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('KEY TAKEAWAYS:');
+console.log('1. Deutsch-Jozsa shows exponential speedup');
+console.log('2. Grover provides quadratic speedup for search');
+console.log('3. Teleportation transfers states without moving qubits');
+console.log('4. Phase estimation underlies many algorithms');
+console.log('5. Quantum advantage varies by problem type');
+console.log('6. Not all problems have quantum speedup');

package/examples/scientific/06-random.js

@@ -0,0 +1,225 @@
+/**
+ * @example Quantum Random Number Generation
+ * @description Generate true random numbers using quantum measurement
+ * 
+ * Quantum mechanics provides a source of true randomness:
+ * - Measurement outcomes are fundamentally unpredictable
+ * - Not pseudo-random, truly random
+ * - Used in cryptography and simulations
+ */
+
+const { ScientificBackend, Hypercomplex } = require('../../modular');
+
+// ===========================================
+// SETUP
+// ===========================================
+
+const backend = new ScientificBackend({ dimension: 16 });
+
+console.log('TinyAleph Quantum Random Number Generator');
+console.log('=========================================\n');
+
+// ===========================================
+// QUANTUM RANDOM BIT
+// ===========================================
+
+console.log('Quantum Random Bit:');
+console.log('-'.repeat(50) + '\n');
+
+console.log('Creating superposition and measuring produces a random bit.\n');
+
+function quantumRandomBit() {
+    // Create |+⟩ state (equal superposition of |0⟩ and |1⟩)
+    var superposition = backend.encode('|+⟩');  // [2, 3] = equal weights
+    var state = backend.primesToState(superposition);
+    
+    // Use the built-in measure method
+    var result = backend.measure(state);
+    return result.outcome;
+}
+
+console.log('Generating 20 quantum random bits:');
+var bits = [];
+for (var i = 0; i < 20; i++) {
+    bits.push(quantumRandomBit());
+}
+console.log('  ' + bits.join(''));
+
+// ===========================================
+// RANDOM INTEGERS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Random Integers:');
+console.log('='.repeat(50) + '\n');
+
+function quantumRandomInt(max) {
+    var bitsNeeded = Math.ceil(Math.log2(max + 1));
+    var attempts = 0;
+    var maxAttempts = 100;  // Prevent infinite loop
+    
+    // Rejection sampling for uniform distribution
+    while (attempts < maxAttempts) {
+        attempts++;
+        var value = 0;
+        for (var i = 0; i < bitsNeeded; i++) {
+            value = (value << 1) | quantumRandomBit();
+        }
+        if (value <= max) {
+            return value;
+        }
+    }
+    // Fallback to modulo if rejection sampling fails
+    return value % (max + 1);
+}
+
+console.log('Random integers 0-9:');
+var ints = [];
+for (var i = 0; i < 10; i++) {
+    ints.push(quantumRandomInt(9));
+}
+console.log('  ' + ints.join(', '));
+
+console.log('\nRandom integers 0-99:');
+var largerInts = [];
+for (var i = 0; i < 5; i++) {
+    largerInts.push(quantumRandomInt(99));
+}
+console.log('  ' + largerInts.join(', '));
+
+// ===========================================
+// RANDOM BYTES
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Random Bytes:');
+console.log('='.repeat(50) + '\n');
+
+function quantumRandomBytes(n) {
+    var bytes = [];
+    for (var i = 0; i < n; i++) {
+        var byte = 0;
+        for (var j = 0; j < 8; j++) {
+            byte = (byte << 1) | quantumRandomBit();
+        }
+        bytes.push(byte);
+    }
+    return bytes;
+}
+
+var randomBytes = quantumRandomBytes(8);
+console.log('8 random bytes (decimal):');
+console.log('  ' + randomBytes.join(', '));
+
+console.log('\nHexadecimal:');
+var hex = randomBytes.map(function(b) {
+    return b.toString(16).padStart(2, '0');
+}).join('');
+console.log('  0x' + hex);
+
+// ===========================================
+// RANDOM UUID
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Random UUID:');
+console.log('='.repeat(50) + '\n');
+
+function quantumUUID() {
+    var bytes = quantumRandomBytes(16);
+    
+    // Set version 4 (random) and variant bits
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    
+    var hex = bytes.map(function(b) {
+        return b.toString(16).padStart(2, '0');
+    });
+    
+    return hex.slice(0, 4).join('') + '-' +
+           hex.slice(4, 6).join('') + '-' +
+           hex.slice(6, 8).join('') + '-' +
+           hex.slice(8, 10).join('') + '-' +
+           hex.slice(10, 16).join('');
+}
+
+console.log('Quantum random UUIDs:');
+for (var i = 0; i < 3; i++) {
+    console.log('  ' + quantumUUID());
+}
+
+// ===========================================
+// STATISTICAL TESTING
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Statistical Testing:');
+console.log('='.repeat(50) + '\n');
+
+function chiSquareTest(observed, expected) {
+    var chiSquare = 0;
+    for (var i = 0; i < observed.length; i++) {
+        var diff = observed[i] - expected[i];
+        chiSquare += (diff * diff) / expected[i];
+    }
+    return chiSquare;
+}
+
+// Generate many random bits and test distribution
+var trials = 500;  // Reduced for faster execution
+var counts = [0, 0];
+
+for (var i = 0; i < trials; i++) {
+    counts[quantumRandomBit()]++;
+}
+
+var expected = [trials / 2, trials / 2];
+var chiSq = chiSquareTest(counts, expected);
+
+console.log('Bit distribution test (' + trials + ' trials):');
+console.log('  Zeros: ' + counts[0] + ' (expected: ' + expected[0] + ')');
+console.log('  Ones:  ' + counts[1] + ' (expected: ' + expected[1] + ')');
+console.log('  Chi-square: ' + chiSq.toFixed(4));
+console.log('  Passes if χ² < 3.84 (95% confidence): ' + (chiSq < 3.84 ? 'PASS' : 'FAIL'));
+
+// ===========================================
+// CRYPTOGRAPHIC APPLICATIONS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Cryptographic Applications:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Quantum randomness is ideal for cryptography:\n');
+
+// Generate a random key
+var keyBits = [];
+for (var i = 0; i < 128; i++) {
+    keyBits.push(quantumRandomBit());
+}
+
+console.log('128-bit random key:');
+var keyHex = '';
+for (var i = 0; i < 128; i += 4) {
+    var nibble = (keyBits[i] << 3) | (keyBits[i+1] << 2) | (keyBits[i+2] << 1) | keyBits[i+3];
+    keyHex += nibble.toString(16);
+}
+console.log('  ' + keyHex);
+
+// Generate random nonce
+console.log('\nRandom nonce (64-bit):');
+var nonce = quantumRandomBytes(8);
+console.log('  ' + nonce.map(function(b) { return b.toString(16).padStart(2, '0'); }).join(''));
+
+// ===========================================
+// KEY TAKEAWAYS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('KEY TAKEAWAYS:');
+console.log('1. Quantum measurement provides true randomness');
+console.log('2. Not pseudo-random - fundamentally unpredictable');
+console.log('3. Build larger random values from random bits');
+console.log('4. Use rejection sampling for uniform distribution');
+console.log('5. Statistical tests verify randomness quality');
+console.log('6. Essential for cryptographic key generation');