@aleph-ai/tinyaleph 1.5.7 → 1.6.1

package/examples/bioinformatics/01-dna-encoding.js

@@ -0,0 +1,108 @@
+/**
+ * @example DNA Encoding
+ * @description Encode DNA sequences as prime-resonant semantic states
+ * 
+ * This example shows how TinyAleph encodes DNA sequences using prime numbers.
+ * Each nucleotide maps to a specific prime:
+ *   A (Adenine)  → 7   (purines get higher primes)
+ *   T (Thymine)  → 2   (lowest energy, pairs with A)
+ *   G (Guanine)  → 11  (highest prime, strongest purine)
+ *   C (Cytosine) → 3   (pairs with G)
+ *   U (Uracil)   → 5   (RNA only, replaces T)
+ */
+
+const { BioinformaticsBackend } = require('../../modular');
+
+// Nucleotide prime mapping
+const NUCLEOTIDE_PRIMES = { A: 7, T: 2, G: 11, C: 3, U: 5 };
+
+// ===========================================
+// SETUP
+// ===========================================
+
+// Create a bioinformatics backend
+const backend = new BioinformaticsBackend();
+
+// ===========================================
+// EXAMPLE CODE
+// ===========================================
+
+// A sample DNA sequence (start codon + some bases)
+const dnaSequence = 'ATGCGATCGATCG';
+
+// Encode the DNA sequence - returns prime array
+const primes = backend.encode(dnaSequence);
+
+// Convert primes to hypercomplex state
+const state = backend.primesToState(primes);
+
+// ===========================================
+// OUTPUT
+// ===========================================
+
+console.log('TinyAleph DNA Encoding Example');
+console.log('==============================\n');
+
+console.log('DNA Sequence:', dnaSequence);
+console.log('Sequence Length:', dnaSequence.length, 'nucleotides');
+
+console.log('\nNucleotide → Prime Mapping:');
+console.log('  A (Adenine)  → 7');
+console.log('  T (Thymine)  → 2');
+console.log('  G (Guanine)  → 11');
+console.log('  C (Cytosine) → 3');
+
+console.log('\nPrime Encoding:');
+for (let i = 0; i < dnaSequence.length; i++) {
+    console.log(`  ${dnaSequence[i]} → ${primes[i]}`);
+}
+
+console.log('\nHypercomplex State (sedenion components):');
+const components = state.c;  // Hypercomplex uses .c for components
+console.log('  Real part:', components[0].toFixed(6));
+console.log('  i:', components[1].toFixed(6));
+console.log('  j:', components[2].toFixed(6));
+console.log('  k:', components[3].toFixed(6));
+console.log('  (remaining 12 dimensions...)\n');
+
+// Verify decoding works
+const decoded = backend.decode(primes);
+console.log('Decoded sequence:', decoded);
+console.log('Round-trip match:', decoded === dnaSequence ? 'YES ✓' : 'NO ✗');
+
+// ===========================================
+// COMPLEMENTARY STRAND
+// ===========================================
+
+console.log('\n==============================');
+console.log('COMPLEMENTARY BASE PAIRING:');
+console.log('==============================\n');
+
+// Compute complement manually (A↔T, G↔C)
+const COMPLEMENT = { 'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G' };
+const complement = dnaSequence.split('').map(b => COMPLEMENT[b] || b).join('');
+
+console.log('Original:   5\'-' + dnaSequence + '-3\'');
+console.log('Complement: 3\'-' + complement + '-5\'');
+
+// In DNA, A pairs with T, G pairs with C
+console.log('\nBase pairing (prime products):');
+for (let i = 0; i < Math.min(5, dnaSequence.length); i++) {
+    const base1 = dnaSequence[i];
+    const base2 = complement[i];
+    const p1 = NUCLEOTIDE_PRIMES[base1];
+    const p2 = NUCLEOTIDE_PRIMES[base2];
+    console.log(`  ${base1}-${base2}: ${p1} × ${p2} = ${p1 * p2}`);
+}
+
+// ===========================================
+// KEY TAKEAWAYS
+// ===========================================
+
+console.log('\n==============================');
+console.log('KEY TAKEAWAYS:');
+console.log('1. DNA nucleotides map to prime numbers (2, 3, 5, 7, 11)');
+console.log('2. Prime encoding preserves sequence structure');
+console.log('3. Hypercomplex states enable mathematical operations');
+console.log('4. Complementary bases have related prime products');
+console.log('5. Round-trip encoding/decoding is lossless');

package/examples/bioinformatics/02-central-dogma.js

@@ -0,0 +1,162 @@
+/**
+ * @example Central Dogma
+ * @description DNA → RNA → Protein: The molecular biology central dogma
+ * 
+ * This example demonstrates how TinyAleph models the central dogma
+ * of molecular biology as entropy-reducing transforms:
+ *   1. Transcription: DNA → mRNA (T→U substitution)
+ *   2. Translation: mRNA → Protein (codon→amino acid)
+ * 
+ * Each step reduces entropy by collapsing possibility space.
+ */
+
+const { BioinformaticsBackend } = require('../../modular');
+
+// ===========================================
+// SETUP
+// ===========================================
+
+const backend = new BioinformaticsBackend();
+
+// A sample gene: Start codon (ATG) + coding sequence + Stop codon (TAA)
+const gene = 'ATGCATGCATACTAA';
+
+// ===========================================
+// TRANSCRIPTION: DNA → mRNA
+// ===========================================
+
+console.log('TinyAleph Central Dogma Example');
+console.log('================================\n');
+
+console.log('STEP 1: TRANSCRIPTION (DNA → mRNA)');
+console.log('----------------------------------\n');
+
+console.log('DNA Template: 5\'-' + gene + '-3\'');
+
+// Encode DNA to primes
+const dnaPrimes = backend.encode(gene);
+
+// Transcribe using the backend's transcription operator
+const transcribeResult = backend.transcribe(dnaPrimes, { force: true });
+const mRNAPrimes = transcribeResult.success ? transcribeResult.rna : dnaPrimes;
+
+// Decode mRNA back to sequence
+const mRNA = backend.decode(mRNAPrimes);
+
+console.log('mRNA Strand:  5\'-' + mRNA + '-3\'');
+console.log('\nTransform: T (Thymine) → U (Uracil)');
+
+// Show the substitution
+let changes = [];
+for (let i = 0; i < gene.length; i++) {
+    if (gene[i] === 'T' && mRNA[i] === 'U') {
+        changes.push(i);
+    }
+}
+console.log('Substitutions at positions:', changes.join(', '));
+
+// ===========================================
+// TRANSLATION: mRNA → Protein
+// ===========================================
+
+console.log('\n\nSTEP 2: TRANSLATION (mRNA → Protein)');
+console.log('-------------------------------------\n');
+
+// Extract codons from mRNA
+const codons = [];
+for (let i = 0; i < mRNA.length - 2; i += 3) {
+    codons.push(mRNA.slice(i, i + 3));
+}
+console.log('Codons:', codons.join(' | '));
+
+// Translate mRNA to protein using the backend
+const translateResult = backend.translate(mRNAPrimes);
+const proteinPrimes = translateResult.success ? translateResult.protein : [];
+const protein = backend.decode(proteinPrimes);
+
+console.log('Amino Acids:', protein.split('').join(' | '));
+
+console.log('\nCodon → Amino Acid mapping:');
+for (let i = 0; i < codons.length; i++) {
+    const aa = protein[i] || '*';
+    const aaName = {
+        'M': 'Methionine (Start)',
+        'H': 'Histidine',
+        'A': 'Alanine', 
+        'Y': 'Tyrosine',
+        '*': 'Stop'
+    }[aa] || aa;
+    console.log(`  ${codons[i]} → ${aa} (${aaName})`);
+}
+
+// ===========================================
+// GENE EXPRESSION: Full Pipeline
+// ===========================================
+
+console.log('\n\nFULL GENE EXPRESSION');
+console.log('--------------------\n');
+
+// Use the express() function to go from DNA directly to protein
+const expressResult = backend.express(dnaPrimes);
+const expressedProtein = expressResult.success ? expressResult.sequence : '';
+
+console.log('DNA:', gene);
+console.log('        ↓ (transcription)');
+console.log('mRNA:', mRNA);
+console.log('        ↓ (translation)');
+console.log('Protein:', expressedProtein || '[No protein - no start codon found]');
+
+// ===========================================
+// ENTROPY ANALYSIS
+// ===========================================
+
+console.log('\n\nENTROPY REDUCTION ANALYSIS');
+console.log('--------------------------\n');
+
+// Calculate effective entropy at each step
+const dnaEntropy = gene.length * Math.log2(4);  // 4 possible nucleotides
+const rnaEntropy = mRNA.length * Math.log2(4);  // 4 possible nucleotides
+const proteinLength = expressedProtein ? expressedProtein.length : 0;
+const proteinEntropy = proteinLength * Math.log2(20);  // 20 amino acids
+
+console.log('Information content:');
+console.log(`  DNA:     ${gene.length} nucleotides × 2 bits = ${dnaEntropy.toFixed(1)} bits`);
+console.log(`  mRNA:    ${mRNA.length} nucleotides × 2 bits = ${rnaEntropy.toFixed(1)} bits`);
+console.log(`  Protein: ${proteinLength} amino acids × 4.32 bits = ${proteinEntropy.toFixed(1)} bits`);
+
+if (proteinLength > 0) {
+    const compression = (1 - proteinEntropy / dnaEntropy) * 100;
+    console.log(`\nEffective compression: ${compression.toFixed(1)}%`);
+    console.log('Translation reduces entropy by mapping 64 codons → 20 amino acids');
+}
+
+// ===========================================
+// PRIME ENCODING VIEW
+// ===========================================
+
+console.log('\n\nPRIME ENCODING VIEW');
+console.log('-------------------\n');
+
+const dnaState = backend.primesToState(dnaPrimes);
+const rnaState = backend.primesToState(mRNAPrimes);
+
+console.log('Hypercomplex state norms:');
+console.log(`  DNA:     ${dnaState.norm().toFixed(4)}`);
+console.log(`  mRNA:    ${rnaState.norm().toFixed(4)}`);
+
+if (proteinPrimes.length > 0) {
+    const proteinState = backend.primesToState(proteinPrimes);
+    console.log(`  Protein: ${proteinState.norm().toFixed(4)}`);
+}
+
+// ===========================================
+// KEY TAKEAWAYS
+// ===========================================
+
+console.log('\n================================');
+console.log('KEY TAKEAWAYS:');
+console.log('1. Transcription: DNA→mRNA is a T→U substitution transform');
+console.log('2. Translation: mRNA→Protein is codon→amino acid mapping');
+console.log('3. Each step is entropy-reducing (collapses possibility space)');
+console.log('4. 64 codons encode 20 amino acids + stop (redundancy)');
+console.log('5. Prime encoding preserves information through transforms');

package/examples/bioinformatics/03-protein-folding.js

@@ -0,0 +1,206 @@
+/**
+ * @example Protein Folding
+ * @description Simulate protein folding using Kuramoto oscillator synchronization
+ * 
+ * This example demonstrates how TinyAleph models protein folding as a 
+ * synchronization problem. Each amino acid is treated as an oscillator,
+ * and folding emerges from oscillator coupling based on:
+ *   - Hydrophobic interactions (drives core formation)
+ *   - Electrostatic attraction/repulsion
+ *   - Prime resonance (hypercomplex coupling)
+ */
+
+const { BioinformaticsBackend } = require('../../modular');
+
+// ===========================================
+// SETUP
+// ===========================================
+
+const backend = new BioinformaticsBackend();
+
+// A short protein sequence with various amino acid types
+// W, L, I, F, V = hydrophobic (want to be in core)
+// K, R, D, E = charged (on surface)
+// M = start codon amino acid
+const proteinSeq = 'MWLKFVEIRLLQ';
+
+// ===========================================
+// AMINO ACID PROPERTIES
+// ===========================================
+
+console.log('TinyAleph Protein Folding Example');
+console.log('==================================\n');
+
+console.log('Protein Sequence:', proteinSeq.split('').join('-'));
+console.log('Length:', proteinSeq.length, 'amino acids\n');
+
+// Classify amino acids
+const hydrophobic = ['L', 'I', 'V', 'F', 'W', 'M', 'A'];
+const positiveCharge = ['K', 'R', 'H'];
+const negativeCharge = ['D', 'E'];
+
+console.log('Amino Acid Properties:');
+console.log('----------------------');
+for (let i = 0; i < proteinSeq.length; i++) {
+    const aa = proteinSeq[i];
+    let type = 'polar';
+    if (hydrophobic.includes(aa)) type = 'hydrophobic';
+    else if (positiveCharge.includes(aa)) type = 'positive (+)';
+    else if (negativeCharge.includes(aa)) type = 'negative (-)';
+    console.log(`  ${i}: ${aa} - ${type}`);
+}
+
+// ===========================================
+// FOLD PROTEIN
+// ===========================================
+
+console.log('\n\nFOLDING SIMULATION (Kuramoto Model)');
+console.log('------------------------------------\n');
+
+// Encode protein and fold
+const proteinPrimes = backend.encode(proteinSeq);
+const foldResult = backend.foldProtein(proteinPrimes);
+
+console.log('Folding result:');
+console.log(`  Success: ${foldResult.success}`);
+console.log(`  Final synchronization: ${(foldResult.orderParameter || 0).toFixed(4)}`);
+console.log(`  Steps: ${foldResult.steps || 0}`);
+
+// ===========================================
+// PHASE ANALYSIS
+// ===========================================
+
+console.log('\n\nPHASE ANALYSIS');
+console.log('--------------\n');
+
+if (foldResult.phases && foldResult.phases.length > 0) {
+    console.log('Final oscillator phases:');
+    for (let i = 0; i < Math.min(foldResult.phases.length, proteinSeq.length); i++) {
+        const phase = foldResult.phases[i];
+        const phaseDegrees = ((phase % (2 * Math.PI)) * 180 / Math.PI).toFixed(1);
+        console.log(`  ${proteinSeq[i]}: ${phaseDegrees}°`);
+    }
+}
+
+// ===========================================
+// CONTACT ANALYSIS
+// ===========================================
+
+console.log('\n\nCONTACT ANALYSIS');
+console.log('----------------\n');
+
+// Calculate contacts from prime similarity
+console.log('Computing residue contacts based on prime resonance...');
+
+const primes = backend.encode(proteinSeq);
+const contacts = [];
+
+// Simple contact prediction based on prime resonance
+for (let i = 0; i < primes.length; i++) {
+    for (let j = i + 2; j < primes.length; j++) {
+        const p1 = primes[i];
+        const p2 = primes[j];
+        
+        // Resonance strength based on GCD and frequency matching
+        const gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
+        const resonance = gcd(p1, p2) / Math.sqrt(p1 * p2);
+        
+        // Hydrophobic attraction
+        const aa1 = proteinSeq[i];
+        const aa2 = proteinSeq[j];
+        const h1 = hydrophobic.includes(aa1) ? 0.3 : 0;
+        const h2 = hydrophobic.includes(aa2) ? 0.3 : 0;
+        
+        const strength = resonance + h1 + h2;
+        
+        if (strength > 0.1) {
+            contacts.push([i, j, strength]);
+        }
+    }
+}
+
+// Sort by strength
+contacts.sort((a, b) => b[2] - a[2]);
+
+console.log('\nTop contacts (by strength):');
+for (const [i, j, strength] of contacts.slice(0, 8)) {
+    console.log(`  ${proteinSeq[i]}(${i}) ↔ ${proteinSeq[j]}(${j}): ${strength.toFixed(3)}`);
+}
+
+// ===========================================
+// CONTACT MAP VISUALIZATION
+// ===========================================
+
+console.log('\n\nCONTACT MAP (text visualization)');
+console.log('----------------------------------\n');
+
+// Build contact strength matrix
+const matrix = Array(proteinSeq.length).fill(null).map(() => 
+    Array(proteinSeq.length).fill(0)
+);
+
+for (const [i, j, strength] of contacts) {
+    matrix[i][j] = strength;
+    matrix[j][i] = strength;
+}
+
+// Print header
+console.log('    ' + proteinSeq.split('').join(' '));
+console.log('    ' + proteinSeq.split('').map(() => '─').join('─'));
+
+for (let i = 0; i < proteinSeq.length; i++) {
+    let row = `${proteinSeq[i]} │ `;
+    for (let j = 0; j < proteinSeq.length; j++) {
+        if (i === j) {
+            row += '●';
+        } else if (matrix[i][j] > 0.5) {
+            row += '█';
+        } else if (matrix[i][j] > 0.3) {
+            row += '▓';
+        } else if (matrix[i][j] > 0.1) {
+            row += '░';
+        } else {
+            row += '·';
+        }
+        row += ' ';
+    }
+    console.log(row);
+}
+
+console.log('\nLegend: ● self, █ strong, ▓ medium, ░ weak, · none');
+
+// ===========================================
+// PRIME RESONANCE VIEW
+// ===========================================
+
+console.log('\n\nPRIME RESONANCE VIEW');
+console.log('--------------------\n');
+
+const proteinState = backend.primesToState(proteinPrimes);
+console.log('Protein hypercomplex state norm:', proteinState.norm().toFixed(4));
+
+// Show prime assignment for each amino acid
+console.log('\nAmino Acid → Prime Mapping:');
+const AMINO_ACID_PRIMES = {
+    'L': 23, 'I': 29, 'V': 31, 'F': 37, 'W': 41, 'M': 43, 'A': 47,
+    'G': 53, 'C': 59, 'P': 61, 'Y': 67, 'S': 71, 'T': 73, 'N': 79, 'Q': 83,
+    'H': 89, 'K': 97, 'R': 101, 'D': 103, 'E': 107
+};
+
+for (const aa of proteinSeq.slice(0, 6).split('')) {
+    const prime = AMINO_ACID_PRIMES[aa] || '?';
+    console.log(`  ${aa} → ${prime}`);
+}
+console.log('  ...');
+
+// ===========================================
+// KEY TAKEAWAYS
+// ===========================================
+
+console.log('\n==================================');
+console.log('KEY TAKEAWAYS:');
+console.log('1. Protein folding modeled as oscillator synchronization');
+console.log('2. Hydrophobic residues cluster (form protein core)');
+console.log('3. Charged residues prefer opposite charges or surface');
+console.log('4. Prime encoding enables resonance-based coupling');
+console.log('5. Contact maps emerge from Kuramoto dynamics');

package/examples/bioinformatics/04-dna-computing.js

@@ -0,0 +1,192 @@
+/**
+ * @example DNA Computing
+ * @description Build logic gates and circuits using DNA strands
+ * 
+ * This example demonstrates DNA computing - using DNA strands to perform
+ * logical computation. The key mechanisms are:
+ *   - DNA hybridization (complementary strands bind)
+ *   - Strand displacement (incoming strand displaces bound strand)
+ *   - Toehold-mediated reactions (short overhangs enable displacement)
+ * 
+ * TinyAleph models these as prime-encoded strand operations.
+ */
+
+const { 
+    BioinformaticsBackend, 
+    DNACircuit, 
+    ANDGate, 
+    ORGate, 
+    NOTGate
+} = require('../../modular');
+
+// ===========================================
+// SETUP
+// ===========================================
+
+const backend = new BioinformaticsBackend();
+
+// ===========================================
+// DNA STRAND BASICS
+// ===========================================
+
+console.log('TinyAleph DNA Computing Example');
+console.log('================================\n');
+
+console.log('DNA STRAND REPRESENTATION');
+console.log('-------------------------\n');
+
+// Create DNA strands using the backend
+const seq1 = 'ATGCGATC';
+const seq2 = 'GATCGCAT';
+
+const strand1Primes = backend.encode(seq1);
+const strand2Primes = backend.encode(seq2);
+
+console.log('Strand 1 (signal-A):');
+console.log(`  Sequence: 5'-${seq1}-3'`);
+console.log(`  Primes: [${strand1Primes.slice(0, 4).join(', ')}...]`);
+console.log(`  State norm: ${backend.primesToState(strand1Primes).norm().toFixed(4)}`);
+
+console.log('\nStrand 2 (signal-B):');
+console.log(`  Sequence: 5'-${seq2}-3'`);
+console.log(`  Primes: [${strand2Primes.slice(0, 4).join(', ')}...]`);
+
+// Check if strands are complementary
+const COMPLEMENT = { 'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G' };
+const comp1 = seq1.split('').map(b => COMPLEMENT[b]).join('');
+const isComplementary = comp1 === seq2;
+console.log(`\nAre strands complementary? ${isComplementary ? 'YES' : 'NO'}`);
+console.log(`  Complement of strand 1: ${comp1}`);
+
+// ===========================================
+// SIMPLE LOGIC GATES
+// ===========================================
+
+console.log('\n\nLOGIC GATES');
+console.log('-----------\n');
+
+// Create a simple AND gate
+const andGate = new ANDGate({ name: 'AND-1' });
+console.log('AND Gate:', andGate.name);
+
+// Test all input combinations (using concentration values 0 or 1)
+console.log('\n  Truth Table:');
+console.log('  A | B | A AND B');
+console.log('  --|---|--------');
+for (const [a, b] of [[0, 0], [0, 1], [1, 0], [1, 1]]) {
+    const result = andGate.evaluate(a, b);
+    console.log(`  ${a} | ${b} |    ${result.output ? 1 : 0}`);
+}
+
+// Create an OR gate
+const orGate = new ORGate({ name: 'OR-1' });
+console.log('\nOR Gate:', orGate.name);
+console.log('\n  Truth Table:');
+console.log('  A | B | A OR B');
+console.log('  --|---|-------');
+for (const [a, b] of [[0, 0], [0, 1], [1, 0], [1, 1]]) {
+    const result = orGate.evaluate(a, b);
+    console.log(`  ${a} | ${b} |   ${result.output ? 1 : 0}`);
+}
+
+// Create a NOT gate
+const notGate = new NOTGate({ name: 'NOT-1' });
+console.log('\nNOT Gate:', notGate.name);
+console.log('\n  Truth Table:');
+console.log('  A | NOT A');
+console.log('  --|------');
+for (const a of [0, 1]) {
+    const result = notGate.evaluate(a);
+    console.log(`  ${a} |   ${result.output ? 1 : 0}`);
+}
+
+// ===========================================
+// DNA CIRCUIT
+// ===========================================
+
+console.log('\n\nDNA CIRCUIT: (A AND B) OR (NOT C)');
+console.log('----------------------------------\n');
+
+const circuit = new DNACircuit('main-circuit');
+
+// Add gates to create: (A AND B) OR (NOT C)
+circuit.addGate('and1', new ANDGate({ name: 'and1' }));
+circuit.addGate('not1', new NOTGate({ name: 'not1' }));
+circuit.addGate('or1', new ORGate({ name: 'or1' }));
+
+// Connect: and1 output → or1 input1, not1 output → or1 input2
+circuit.connect('and1', 'or1', 1);
+circuit.connect('not1', 'or1', 2);
+
+console.log('Circuit structure:');
+console.log('  A ──┐');
+console.log('      ├──[AND]──┐');
+console.log('  B ──┘         ├──[OR]── result');
+console.log('      ┌──[NOT]──┘');
+console.log('  C ──┘');
+
+console.log('\nCircuit gates:', circuit.listGates ? circuit.listGates().map(g => g.name).join(', ') : [...circuit.gates.keys()].join(', '));
+
+// Manual evaluation for all input combinations
+console.log('\nTruth Table:');
+console.log('A | B | C | (A∧B)∨(¬C)');
+console.log('--|---|---|----------');
+
+for (const a of [0, 1]) {
+    for (const b of [0, 1]) {
+        for (const c of [0, 1]) {
+            // Manually compute the logic
+            const andResult = a && b;
+            const notResult = !c;
+            const finalResult = andResult || notResult;
+            console.log(`${a} | ${b} | ${c} |     ${finalResult ? 1 : 0}`);
+        }
+    }
+}
+
+// ===========================================
+// BINDING AFFINITY
+// ===========================================
+
+console.log('\n\nBINDING AFFINITY BETWEEN STRANDS');
+console.log('---------------------------------\n');
+
+// Test binding between different strands
+const strandsToTest = [
+    { name: 'Strand 1', seq: seq1 },
+    { name: 'Complement', seq: comp1 },
+    { name: 'Different', seq: 'GGGGCCCC' }
+];
+
+console.log('Binding affinities relative to Strand 1:');
+
+for (const strand of strandsToTest) {
+    const primes = backend.encode(strand.seq);
+    const result = backend.bindingAffinity(strand1Primes, primes);
+    console.log(`  ${strand.name} (${strand.seq}): ${result.affinity.toFixed(4)}`);
+}
+
+// ===========================================
+// DNA COMPUTING ADVANTAGES
+// ===========================================
+
+console.log('\n\nDNA COMPUTING ADVANTAGES');
+console.log('------------------------\n');
+
+console.log('1. Massive parallelism: billions of molecules compute simultaneously');
+console.log('2. Energy efficient: reactions occur at room temperature');
+console.log('3. Ultra-dense storage: 1 gram DNA ≈ 215 petabytes');
+console.log('4. Biocompatibility: can interface with living systems');
+console.log('5. Self-assembly: complex structures emerge from simple rules');
+
+// ===========================================
+// KEY TAKEAWAYS
+// ===========================================
+
+console.log('\n================================');
+console.log('KEY TAKEAWAYS:');
+console.log('1. DNA strands encode information as prime sequences');
+console.log('2. Logic gates use strand displacement reactions');
+console.log('3. Circuits compose gates for complex logic');
+console.log('4. Binding affinity measured via prime resonance');
+console.log('5. TinyAleph models DNA computing in hypercomplex space');