@aleph-ai/tinyaleph 1.5.6 → 1.6.0

package/examples/scientific/01-single-qubit.js

@@ -0,0 +1,185 @@
+/**
+ * @example Single Qubit Operations
+ * @description Simulate single qubit quantum gates
+ * 
+ * TinyAleph can simulate quantum computing concepts:
+ * - Qubits represented as hypercomplex states
+ * - Quantum gates as transformations
+ * - Measurement with probabilistic collapse
+ */
+
+const { ScientificBackend, Hypercomplex } = require('../../modular');
+
+// ===========================================
+// SETUP
+// ===========================================
+
+const backend = new ScientificBackend({ dimension: 2 });
+
+console.log('TinyAleph Single Qubit Example');
+console.log('==============================\n');
+
+// ===========================================
+// QUBIT BASICS
+// ===========================================
+
+console.log('Qubit Basics:');
+console.log('-'.repeat(50) + '\n');
+
+console.log('A qubit is a quantum bit that can be in superposition.');
+console.log('Classical: 0 or 1');
+console.log('Quantum: α|0⟩ + β|1⟩ where |α|² + |β|² = 1\n');
+
+// Create basis states
+var ket0 = backend.encode('|0⟩');
+var ket1 = backend.encode('|1⟩');
+
+console.log('Basis state |0⟩ primes: [' + ket0.join(', ') + ']');
+console.log('Basis state |1⟩ primes: [' + ket1.join(', ') + ']');
+
+// ===========================================
+// QUANTUM GATES
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Quantum Gates:');
+console.log('='.repeat(50) + '\n');
+
+// Hadamard gate - creates superposition
+console.log('Hadamard Gate (H):');
+console.log('  Creates equal superposition from basis states');
+console.log('  H|0⟩ = (|0⟩ + |1⟩)/√2');
+console.log('  H|1⟩ = (|0⟩ - |1⟩)/√2\n');
+
+var h_state = backend.applyGate(ket0, 'H');
+console.log('  H|0⟩ result primes: [' + h_state.join(', ') + ']\n');
+
+// Pauli-X gate - bit flip
+console.log('Pauli-X Gate (NOT):');
+console.log('  Flips the qubit state');
+console.log('  X|0⟩ = |1⟩');
+console.log('  X|1⟩ = |0⟩\n');
+
+var x_state = backend.applyGate(ket0, 'X');
+console.log('  X|0⟩ result primes: [' + x_state.join(', ') + ']\n');
+
+// Pauli-Z gate - phase flip
+console.log('Pauli-Z Gate:');
+console.log('  Flips the phase of |1⟩');
+console.log('  Z|0⟩ = |0⟩');
+console.log('  Z|1⟩ = -|1⟩\n');
+
+var z_state = backend.applyGate(ket1, 'Z');
+console.log('  Z|1⟩ result primes: [' + z_state.join(', ') + ']\n');
+
+// ===========================================
+// SUPERPOSITION
+// ===========================================
+
+console.log('='.repeat(50));
+console.log('Superposition:');
+console.log('='.repeat(50) + '\n');
+
+// Create superposition state
+var superposition = backend.applyGate(ket0, 'H');
+var state = backend.primesToState(superposition);
+
+console.log('Superposition |+⟩ = H|0⟩:');
+console.log('  State norm: ' + state.norm().toFixed(4));
+console.log('  First components: [' + state.c.slice(0, 2).map(function(v) { return v.toFixed(4); }).join(', ') + ']\n');
+
+// ===========================================
+// MEASUREMENT
+// ===========================================
+
+console.log('='.repeat(50));
+console.log('Measurement:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Measuring a superposition collapses it probabilistically:\n');
+
+// Measure superposition multiple times
+var measurements = { '0': 0, '1': 0 };
+var trials = 100;
+
+for (var i = 0; i < trials; i++) {
+    var superState = backend.applyGate(ket0, 'H');
+    var qstate = backend.primesToState(superState);
+    var result = backend.measure(qstate);
+    measurements[result]++;
+}
+
+console.log('Measuring |+⟩ = (|0⟩ + |1⟩)/√2, ' + trials + ' trials:');
+console.log('  |0⟩: ' + measurements['0'] + ' (' + (measurements['0']/trials*100).toFixed(1) + '%)');
+console.log('  |1⟩: ' + measurements['1'] + ' (' + (measurements['1']/trials*100).toFixed(1) + '%)');
+console.log('  Expected: ~50% each\n');
+
+// ===========================================
+// GATE SEQUENCES
+// ===========================================
+
+console.log('='.repeat(50));
+console.log('Gate Sequences:');
+console.log('='.repeat(50) + '\n');
+
+// H then H should return to original
+console.log('H·H = I (identity):');
+var hh = backend.applyGate(backend.applyGate(ket0, 'H'), 'H');
+console.log('  H(H|0⟩) primes: [' + hh.join(', ') + ']');
+console.log('  Original |0⟩: [' + ket0.join(', ') + ']\n');
+
+// X·X = I
+console.log('X·X = I (identity):');
+var xx = backend.applyGate(backend.applyGate(ket0, 'X'), 'X');
+console.log('  X(X|0⟩) primes: [' + xx.join(', ') + ']');
+console.log('  Original |0⟩: [' + ket0.join(', ') + ']\n');
+
+// H·X·H = Z
+console.log('H·X·H = Z (gate identity):');
+var hxh = backend.applyGate(backend.applyGate(backend.applyGate(ket1, 'H'), 'X'), 'H');
+var z_direct = backend.applyGate(ket1, 'Z');
+console.log('  H(X(H|1⟩)) primes: [' + hxh.join(', ') + ']');
+console.log('  Z|1⟩ primes: [' + z_direct.join(', ') + ']\n');
+
+// ===========================================
+// BLOCH SPHERE VISUALIZATION
+// ===========================================
+
+console.log('='.repeat(50));
+console.log('Bloch Sphere Representation:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Single qubit states can be visualized on a Bloch sphere:');
+console.log('  |0⟩ = North pole');
+console.log('  |1⟩ = South pole');
+console.log('  |+⟩ = Positive X axis');
+console.log('  |-⟩ = Negative X axis');
+console.log('  |i⟩ = Positive Y axis');
+console.log('  |-i⟩ = Negative Y axis\n');
+
+var states = [
+    { name: '|0⟩', primes: ket0 },
+    { name: '|1⟩', primes: ket1 },
+    { name: '|+⟩', primes: backend.applyGate(ket0, 'H') },
+    { name: '|-⟩', primes: backend.applyGate(ket1, 'H') }
+];
+
+console.log('State representations:');
+for (var s = 0; s < states.length; s++) {
+    var st = states[s];
+    var qstate = backend.primesToState(st.primes);
+    console.log('  ' + st.name + ': norm=' + qstate.norm().toFixed(4) + ', primes=[' + st.primes.join(', ') + ']');
+}
+
+// ===========================================
+// KEY TAKEAWAYS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('KEY TAKEAWAYS:');
+console.log('1. Qubits can be in superposition of |0⟩ and |1⟩');
+console.log('2. Hadamard gate creates equal superposition');
+console.log('3. Pauli gates flip bits or phases');
+console.log('4. Measurement collapses superposition probabilistically');
+console.log('5. Gates can be composed into sequences');
+console.log('6. Bloch sphere visualizes single qubit states');

package/examples/scientific/02-two-qubit.js

@@ -0,0 +1,209 @@
+/**
+ * @example Two-Qubit Systems
+ * @description Simulate two-qubit quantum systems and entanglement
+ * 
+ * Two-qubit systems enable:
+ * - Tensor product states
+ * - Entanglement
+ * - Two-qubit gates like CNOT
+ */
+
+const { ScientificBackend, Hypercomplex } = require('../../modular');
+
+// ===========================================
+// SETUP
+// ===========================================
+
+const backend = new ScientificBackend({ dimension: 4 });
+
+console.log('TinyAleph Two-Qubit System Example');
+console.log('===================================\n');
+
+// ===========================================
+// TWO-QUBIT BASICS
+// ===========================================
+
+console.log('Two-Qubit Basics:');
+console.log('-'.repeat(50) + '\n');
+
+console.log('A two-qubit system has 4 basis states:');
+console.log('  |00⟩, |01⟩, |10⟩, |11⟩');
+console.log('  General state: α|00⟩ + β|01⟩ + γ|10⟩ + δ|11⟩');
+console.log('  where |α|² + |β|² + |γ|² + |δ|² = 1\n');
+
+// Create basis states
+var ket00 = backend.encode('|00⟩');
+var ket01 = backend.encode('|01⟩');
+var ket10 = backend.encode('|10⟩');
+var ket11 = backend.encode('|11⟩');
+
+console.log('Basis states:');
+console.log('  |00⟩ primes: [' + ket00.join(', ') + ']');
+console.log('  |01⟩ primes: [' + ket01.join(', ') + ']');
+console.log('  |10⟩ primes: [' + ket10.join(', ') + ']');
+console.log('  |11⟩ primes: [' + ket11.join(', ') + ']');
+
+// ===========================================
+// TENSOR PRODUCTS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Tensor Products:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Two independent qubits combine via tensor product:');
+console.log('  |ψ₁⟩ ⊗ |ψ₂⟩\n');
+
+// Simulate tensor product of two qubits
+function tensorProduct(q1, q2) {
+    // In full simulation, this would create a 4-dimensional state
+    // Here we use encoding to represent the combined state
+    var label = '|' + q1 + q2 + '⟩';
+    return backend.encode(label);
+}
+
+var tp_00 = tensorProduct('0', '0');
+var tp_01 = tensorProduct('0', '1');
+var tp_10 = tensorProduct('1', '0');
+var tp_11 = tensorProduct('1', '1');
+
+console.log('Tensor products:');
+console.log('  |0⟩ ⊗ |0⟩ = |00⟩: [' + tp_00.join(', ') + ']');
+console.log('  |0⟩ ⊗ |1⟩ = |01⟩: [' + tp_01.join(', ') + ']');
+console.log('  |1⟩ ⊗ |0⟩ = |10⟩: [' + tp_10.join(', ') + ']');
+console.log('  |1⟩ ⊗ |1⟩ = |11⟩: [' + tp_11.join(', ') + ']');
+
+// ===========================================
+// CNOT GATE
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('CNOT Gate (Controlled-NOT):');
+console.log('='.repeat(50) + '\n');
+
+console.log('CNOT flips the target qubit if control qubit is |1⟩:');
+console.log('  CNOT|00⟩ = |00⟩');
+console.log('  CNOT|01⟩ = |01⟩');
+console.log('  CNOT|10⟩ = |11⟩  (target flipped)');
+console.log('  CNOT|11⟩ = |10⟩  (target flipped)\n');
+
+// Simulate CNOT
+function applyCNOT(primes) {
+    var state = primes.join('');
+    // Map CNOT action based on input state
+    if (state === ket10.join('')) return ket11;
+    if (state === ket11.join('')) return ket10;
+    return primes;  // |00⟩ and |01⟩ unchanged
+}
+
+console.log('CNOT results:');
+console.log('  CNOT|00⟩ = [' + applyCNOT(ket00).join(', ') + ']');
+console.log('  CNOT|01⟩ = [' + applyCNOT(ket01).join(', ') + ']');
+console.log('  CNOT|10⟩ = [' + applyCNOT(ket10).join(', ') + ']');
+console.log('  CNOT|11⟩ = [' + applyCNOT(ket11).join(', ') + ']');
+
+// ===========================================
+// ENTANGLEMENT
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Entanglement:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Entangled states cannot be written as tensor products.');
+console.log('Bell states are maximally entangled:\n');
+
+// Bell states
+console.log('Bell states:');
+console.log('  |Φ+⟩ = (|00⟩ + |11⟩)/√2');
+console.log('  |Φ-⟩ = (|00⟩ - |11⟩)/√2');
+console.log('  |Ψ+⟩ = (|01⟩ + |10⟩)/√2');
+console.log('  |Ψ-⟩ = (|01⟩ - |10⟩)/√2\n');
+
+// Create Bell state |Φ+⟩: H on first qubit, then CNOT
+console.log('Creating |Φ+⟩ = (|00⟩ + |11⟩)/√2:');
+console.log('  1. Start with |00⟩');
+console.log('  2. Apply H to first qubit -> (|0⟩+|1⟩)/√2 ⊗ |0⟩');
+console.log('  3. Apply CNOT -> (|00⟩ + |11⟩)/√2');
+
+// Simulate Bell state creation
+var bellState = backend.encode('|Phi+⟩');
+console.log('  Bell state |Φ+⟩ primes: [' + bellState.join(', ') + ']');
+
+// ===========================================
+// ENTANGLEMENT PROPERTIES
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Entanglement Properties:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Key properties of entangled states:');
+console.log('  1. Non-local correlations');
+console.log('  2. Cannot be factored into independent states');
+console.log('  3. Measuring one qubit affects the other instantly');
+console.log('  4. Basis of quantum communication and computing\n');
+
+// Simulate measuring entangled pair
+console.log('Measuring Bell state |Φ+⟩:');
+console.log('  If first qubit = |0⟩ -> second qubit = |0⟩');
+console.log('  If first qubit = |1⟩ -> second qubit = |1⟩');
+console.log('  Always perfectly correlated!\n');
+
+// Measurement simulation
+var bellMeasurements = { '00': 0, '11': 0 };
+var trials = 100;
+
+for (var i = 0; i < trials; i++) {
+    // Simulate Bell state measurement
+    var r = Math.random();
+    if (r < 0.5) {
+        bellMeasurements['00']++;
+    } else {
+        bellMeasurements['11']++;
+    }
+}
+
+console.log('Simulated measurements (' + trials + ' trials):');
+console.log('  |00⟩: ' + bellMeasurements['00'] + ' (' + (bellMeasurements['00']/trials*100).toFixed(1) + '%)');
+console.log('  |11⟩: ' + bellMeasurements['11'] + ' (' + (bellMeasurements['11']/trials*100).toFixed(1) + '%)');
+console.log('  Note: |01⟩ and |10⟩ never occur (perfect correlation)');
+
+// ===========================================
+// TWO-QUBIT GATES
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Two-Qubit Gates:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Common two-qubit gates:\n');
+
+console.log('CNOT (Controlled-NOT):');
+console.log('  Control=|1⟩ flips target');
+
+console.log('\nCZ (Controlled-Z):');
+console.log('  Control=|1⟩ applies Z to target');
+console.log('  CZ|11⟩ = -|11⟩\n');
+
+console.log('SWAP:');
+console.log('  Exchanges qubit values');
+console.log('  SWAP|01⟩ = |10⟩');
+console.log('  SWAP|10⟩ = |01⟩\n');
+
+console.log('iSWAP:');
+console.log('  SWAP with phase');
+console.log('  iSWAP|01⟩ = i|10⟩');
+
+// ===========================================
+// KEY TAKEAWAYS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('KEY TAKEAWAYS:');
+console.log('1. Two qubits have 4 basis states');
+console.log('2. Independent qubits combine via tensor product');
+console.log('3. CNOT creates entanglement');
+console.log('4. Bell states are maximally entangled');
+console.log('5. Entangled qubits show perfect correlations');
+console.log('6. Two-qubit gates enable quantum algorithms');

package/examples/scientific/03-quantum-circuits.js

@@ -0,0 +1,270 @@
+/**
+ * @example Quantum Circuits
+ * @description Build and run quantum circuits
+ * 
+ * Quantum circuits are sequences of quantum gates:
+ * - Compose gates into circuits
+ * - Execute circuits on quantum states
+ * - Measure outputs
+ */
+
+const { ScientificBackend, Hypercomplex } = require('../../modular');
+
+// ===========================================
+// SETUP
+// ===========================================
+
+const backend = new ScientificBackend({ dimension: 4 });
+
+console.log('TinyAleph Quantum Circuits Example');
+console.log('===================================\n');
+
+// ===========================================
+// QUANTUM CIRCUIT CLASS
+// ===========================================
+
+function QuantumCircuit(numQubits) {
+    this.numQubits = numQubits;
+    this.gates = [];
+}
+
+QuantumCircuit.prototype.h = function(qubit) {
+    this.gates.push({ gate: 'H', qubit: qubit });
+    return this;
+};
+
+QuantumCircuit.prototype.x = function(qubit) {
+    this.gates.push({ gate: 'X', qubit: qubit });
+    return this;
+};
+
+QuantumCircuit.prototype.z = function(qubit) {
+    this.gates.push({ gate: 'Z', qubit: qubit });
+    return this;
+};
+
+QuantumCircuit.prototype.cnot = function(control, target) {
+    this.gates.push({ gate: 'CNOT', control: control, target: target });
+    return this;
+};
+
+QuantumCircuit.prototype.measure = function() {
+    this.gates.push({ gate: 'MEASURE' });
+    return this;
+};
+
+QuantumCircuit.prototype.toString = function() {
+    var lines = [];
+    for (var i = 0; i < this.numQubits; i++) {
+        lines.push('q' + i + ': ');
+    }
+    
+    for (var g = 0; g < this.gates.length; g++) {
+        var gate = this.gates[g];
+        for (var i = 0; i < this.numQubits; i++) {
+            if (gate.gate === 'H' && gate.qubit === i) {
+                lines[i] += '--[H]--';
+            } else if (gate.gate === 'X' && gate.qubit === i) {
+                lines[i] += '--[X]--';
+            } else if (gate.gate === 'Z' && gate.qubit === i) {
+                lines[i] += '--[Z]--';
+            } else if (gate.gate === 'CNOT' && gate.control === i) {
+                lines[i] += '--[●]--';
+            } else if (gate.gate === 'CNOT' && gate.target === i) {
+                lines[i] += '--[⊕]--';
+            } else if (gate.gate === 'MEASURE') {
+                lines[i] += '--[M]--';
+            } else {
+                lines[i] += '-------';
+            }
+        }
+    }
+    
+    return lines.join('\n');
+};
+
+// ===========================================
+// BASIC CIRCUITS
+// ===========================================
+
+console.log('Basic Quantum Circuits:');
+console.log('-'.repeat(50) + '\n');
+
+// Create a simple circuit
+var circuit1 = new QuantumCircuit(2);
+circuit1.h(0).cnot(0, 1).measure();
+
+console.log('Bell State Circuit (creates entanglement):');
+console.log(circuit1.toString());
+console.log('\nThis creates: (|00⟩ + |11⟩)/√2\n');
+
+// Another circuit
+var circuit2 = new QuantumCircuit(2);
+circuit2.x(0).h(1).cnot(1, 0).measure();
+
+console.log('Custom Circuit:');
+console.log(circuit2.toString());
+console.log('');
+
+// ===========================================
+// CIRCUIT EXECUTION
+// ===========================================
+
+console.log('='.repeat(50));
+console.log('Circuit Execution:');
+console.log('='.repeat(50) + '\n');
+
+function executeCircuit(circuit, backend) {
+    // Initialize to |00...0⟩
+    var stateLabel = '|' + '0'.repeat(circuit.numQubits) + '⟩';
+    var state = backend.encode(stateLabel);
+    
+    // Track state through gates
+    var history = [{ step: 'init', state: stateLabel }];
+    
+    for (var g = 0; g < circuit.gates.length; g++) {
+        var gate = circuit.gates[g];
+        
+        if (gate.gate === 'MEASURE') {
+            history.push({ step: 'measure', state: 'collapse' });
+        } else {
+            // Apply gate (simplified simulation)
+            var newState = backend.applyGate(state, gate.gate);
+            history.push({ step: gate.gate + ' q' + (gate.qubit !== undefined ? gate.qubit : gate.control), state: newState.join(',') });
+            state = newState;
+        }
+    }
+    
+    return history;
+}
+
+console.log('Executing Bell State Circuit:\n');
+var history = executeCircuit(circuit1, backend);
+for (var i = 0; i < history.length; i++) {
+    var step = history[i];
+    console.log('  Step ' + i + ' (' + step.step + '): ' + (typeof step.state === 'string' ? step.state : '[' + step.state + ']'));
+}
+
+// ===========================================
+// PARAMETERIZED CIRCUITS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Parameterized Circuits:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Parameterized circuits have adjustable rotation angles.');
+console.log('Used in variational quantum algorithms like VQE and QAOA.\n');
+
+function ParameterizedCircuit(numQubits) {
+    QuantumCircuit.call(this, numQubits);
+    this.parameters = {};
+}
+
+ParameterizedCircuit.prototype = Object.create(QuantumCircuit.prototype);
+
+ParameterizedCircuit.prototype.rx = function(qubit, theta) {
+    this.gates.push({ gate: 'RX', qubit: qubit, theta: theta });
+    return this;
+};
+
+ParameterizedCircuit.prototype.ry = function(qubit, theta) {
+    this.gates.push({ gate: 'RY', qubit: qubit, theta: theta });
+    return this;
+};
+
+ParameterizedCircuit.prototype.rz = function(qubit, theta) {
+    this.gates.push({ gate: 'RZ', qubit: qubit, theta: theta });
+    return this;
+};
+
+var paramCircuit = new ParameterizedCircuit(2);
+paramCircuit.ry(0, 'theta1').ry(1, 'theta2').cnot(0, 1);
+
+console.log('Parameterized Circuit:');
+console.log('  RY(θ₁) on q0');
+console.log('  RY(θ₂) on q1');
+console.log('  CNOT(q0, q1)');
+console.log('\nParameters: θ₁ = 0.5, θ₂ = 1.2');
+
+// ===========================================
+// COMMON CIRCUIT PATTERNS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Common Circuit Patterns:');
+console.log('='.repeat(50) + '\n');
+
+// GHZ state
+console.log('GHZ State (3 qubits):');
+console.log('  Creates: (|000⟩ + |111⟩)/√2');
+var ghz = new QuantumCircuit(3);
+ghz.h(0).cnot(0, 1).cnot(0, 2);
+console.log(ghz.toString());
+
+// W state
+console.log('\nW State (conceptual):');
+console.log('  Creates: (|001⟩ + |010⟩ + |100⟩)/√3');
+console.log('  More complex circuit required\n');
+
+// Teleportation
+console.log('Quantum Teleportation (3 qubits):');
+console.log('  Transfers quantum state using entanglement');
+var teleport = new QuantumCircuit(3);
+teleport.h(1).cnot(1, 2);  // Create Bell pair
+teleport.cnot(0, 1).h(0);   // Bell measurement
+teleport.measure();
+console.log(teleport.toString());
+
+// ===========================================
+// CIRCUIT DEPTH AND WIDTH
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Circuit Metrics:');
+console.log('='.repeat(50) + '\n');
+
+function analyzeCircuit(circuit) {
+    var width = circuit.numQubits;
+    var depth = 0;
+    var gateCount = 0;
+    var gateCounts = {};
+    
+    for (var g = 0; g < circuit.gates.length; g++) {
+        var gate = circuit.gates[g];
+        if (gate.gate !== 'MEASURE') {
+            gateCount++;
+            gateCounts[gate.gate] = (gateCounts[gate.gate] || 0) + 1;
+        }
+    }
+    
+    // Simplified depth calculation
+    depth = circuit.gates.filter(function(g) { return g.gate !== 'MEASURE'; }).length;
+    
+    return {
+        width: width,
+        depth: depth,
+        gateCount: gateCount,
+        gateCounts: gateCounts
+    };
+}
+
+var metrics = analyzeCircuit(circuit1);
+console.log('Bell State Circuit Metrics:');
+console.log('  Width (qubits): ' + metrics.width);
+console.log('  Depth (layers): ' + metrics.depth);
+console.log('  Total gates: ' + metrics.gateCount);
+console.log('  Gate breakdown: ' + JSON.stringify(metrics.gateCounts));
+
+// ===========================================
+// KEY TAKEAWAYS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('KEY TAKEAWAYS:');
+console.log('1. Circuits are sequences of quantum gates');
+console.log('2. Gates act on specific qubits');
+console.log('3. CNOT connects qubits (creates entanglement)');
+console.log('4. Parameterized circuits enable optimization');
+console.log('5. Circuit depth affects noise and runtime');
+console.log('6. Common patterns: Bell, GHZ, teleportation');