@aleph-ai/tinyaleph 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Sebastian Schepis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,278 @@
+# @aleph-ai/tinyaleph
+
+**Prime-resonant semantic computing framework**
+
+A novel computational paradigm that encodes meaning as prime number signatures, embeds them in hypercomplex space, and performs reasoning through entropy minimization and oscillator synchronization.
+
+[![npm version](https://badge.fury.io/js/@sschepis%2Ftinyaleph.svg)](https://www.npmjs.com/package/@aleph-ai/tinyaleph)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- **Prime Semantics**: Encode concepts as unique prime number signatures
+- **Hypercomplex Algebra**: 16-dimensional sedenion space with non-commutative multiplication
+- **Oscillator Dynamics**: Kuramoto-model synchronization for coherent reasoning
+- **Entropy Minimization**: Reasoning as reduction of semantic uncertainty
+- **Multiple Backends**: Semantic (NLP), Cryptographic (hashing), Scientific (quantum-inspired)
+
+## Installation
+
+```bash
+npm install @aleph-ai/tinyaleph
+```
+
+## Quick Start
+
+```javascript
+const { createEngine, SemanticBackend } = require('@aleph-ai/tinyaleph');
+
+// Load configuration
+const config = require('@aleph-ai/tinyaleph/data.json');
+
+// Create a semantic engine
+const engine = createEngine('semantic', config);
+
+// Process a query
+const result = engine.run('What is the relationship between wisdom and truth?');
+
+console.log('Output:', result.output);
+console.log('Entropy:', result.entropy);
+console.log('Steps:', result.steps.length);
+```
+
+## Core Concepts
+
+### Prime Encoding
+
+Every concept maps to a unique set of prime numbers:
+
+```javascript
+const backend = new SemanticBackend(config);
+
+const primes = backend.encode('love and wisdom');
+console.log(primes);  // [2, 3, 5, 7, 11, ...]
+```
+
+### Hypercomplex States
+
+Primes embed into 16-dimensional sedenion space:
+
+```javascript
+const { Hypercomplex } = require('@aleph-ai/tinyaleph');
+
+// Create a state
+const state = new Hypercomplex(16);
+state.excite([2, 3, 5]);  // Excite with primes
+
+// States support multiplication (non-commutative!)
+const combined = state1.multiply(state2);
+console.log(state1.multiply(state2) !== state2.multiply(state1));  // true
+```
+
+### Entropy-Based Reasoning
+
+Reasoning reduces entropy through semantic transforms:
+
+```javascript
+const engine = createEngine('semantic', config);
+const result = engine.run('Confused question here');
+
+// Watch entropy decrease through reasoning steps
+for (const step of result.steps) {
+  console.log(`Step ${step.step}: entropy ${step.entropyAfter.toFixed(3)}`);
+}
+```
+
+## Backends
+
+### Semantic Backend
+
+Natural language understanding and concept mapping:
+
+```javascript
+const { SemanticBackend } = require('@aleph-ai/tinyaleph');
+
+const backend = new SemanticBackend(config);
+
+// Tokenize
+const tokens = backend.tokenize('Love is truth');
+
+// Encode to primes
+const primes = backend.encode('Love is truth');
+
+// Decode back
+const text = backend.decode(primes);
+
+// Compare concepts
+const state1 = backend.textToOrderedState('wisdom');
+const state2 = backend.textToOrderedState('knowledge');
+console.log('Similarity:', state1.coherence(state2));
+```
+
+### Cryptographic Backend
+
+Semantic hashing and key derivation:
+
+```javascript
+const { CryptographicBackend, hash, deriveKey } = require('@aleph-ai/tinyaleph');
+
+// Quick hash
+const h = hash('my secret data');
+
+// Key derivation
+const key = deriveKey('password', 'salt', 32, 10000);
+
+// Full backend
+const crypto = new CryptographicBackend(config);
+const semanticHash = crypto.hash('similar meanings produce similar hashes');
+```
+
+### Scientific Backend
+
+Quantum-inspired computation:
+
+```javascript
+const { ScientificBackend } = require('@aleph-ai/tinyaleph');
+
+const backend = new ScientificBackend(config);
+
+// Create quantum-like states
+const state = backend.createRandomState();
+const basis = backend.createBasisState(0);
+
+// Superposition
+const superposition = backend.superpose(state, 0.5, basis, 0.5);
+
+// Measurement
+const result = backend.measure(superposition, [basis]);
+```
+
+## Physics Engine
+
+### Oscillators
+
+```javascript
+const { Oscillator, OscillatorBank, KuramotoModel } = require('@aleph-ai/tinyaleph');
+
+// Create oscillator bank
+const bank = new OscillatorBank(16);
+
+// Excite with primes
+bank.excite([2, 3, 5, 7]);
+
+// Kuramoto synchronization
+const kuramoto = new KuramotoModel(bank, { coupling: 0.1 });
+kuramoto.step(0.01);
+
+console.log('Order parameter:', kuramoto.orderParameter());
+```
+
+### Entropy and Stability
+
+```javascript
+const { shannonEntropy, estimateLyapunov, stateEntropy } = require('@aleph-ai/tinyaleph');
+
+// Calculate entropy
+const entropy = stateEntropy(state);
+
+// Estimate Lyapunov exponent for stability
+const lambda = estimateLyapunov(entropyTimeSeries);
+console.log('Stable:', lambda < 0);
+```
+
+## API Overview
+
+### Main Exports
+
+| Export | Description |
+|--------|-------------|
+| `createEngine(type, config)` | Create engine with backend |
+| `AlephEngine` | Unified computation engine |
+| `SemanticBackend` | Natural language processing |
+| `CryptographicBackend` | Hashing and key derivation |
+| `ScientificBackend` | Quantum-inspired computation |
+| `Hypercomplex` | Sedenion algebra |
+| `Oscillator` / `OscillatorBank` | Phase-amplitude oscillators |
+| `KuramotoModel` | Coupled oscillator synchronization |
+| `hash(input)` | Quick semantic hash |
+| `deriveKey(pass, salt)` | Quick key derivation |
+
+### Sub-modules
+
+```javascript
+// Direct module access
+const { core, physics, backends, engine } = require('@aleph-ai/tinyaleph');
+
+// Or import sub-modules directly
+const core = require('@aleph-ai/tinyaleph/core');
+const physics = require('@aleph-ai/tinyaleph/physics');
+const backends = require('@aleph-ai/tinyaleph/backends');
+const engine = require('@aleph-ai/tinyaleph/engine');
+```
+
+## Documentation
+
+Full documentation is available in the `docs/` directory:
+
+- **[Theory](./docs/theory/README.md)**: Mathematical foundations
+  - Prime semantics, hypercomplex algebra, oscillator dynamics
+  - Entropy minimization, non-commutativity, temporal emergence
+  
+- **[Guide](./docs/guide/README.md)**: Practical tutorials
+  - Quick start, semantic computing, cryptographic applications
+  - Scientific computing, LLM integration, advanced topics
+  
+- **[Reference](./docs/reference/README.md)**: Complete API documentation
+  - Core module, physics module, backends, engine
+
+## Examples
+
+Run the included demos:
+
+```bash
+# Basic modular demo
+npm run demo
+
+# Two-layer meaning demo
+npm run demo:two-layer
+
+# Performance benchmark
+npm run benchmark
+
+# Interactive chat
+npm run chat
+```
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                        AlephEngine                              │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────────┐ │
+│  │ Oscillators │◄─┤   Field     │◄─┤      Transform          │ │
+│  │  (Kuramoto) │  │  (Sedenion) │  │      Pipeline           │ │
+│  └─────────────┘  └─────────────┘  └─────────────────────────┘ │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+         ┌────────────────────┼────────────────────┐
+         ▼                    ▼                    ▼
+┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
+│ SemanticBackend │ │CryptographicBack│ │ScientificBackend│
+│                 │ │                 │ │                 │
+│ • Tokenization  │ │ • Hash          │ │ • Quantum sim   │
+│ • Prime encode  │ │ • Key derive    │ │ • Wave collapse │
+│ • Transforms    │ │ • Verify        │ │ • Measurement   │
+└─────────────────┘ └─────────────────┘ └─────────────────┘
+```
+
+## Requirements
+
+- Node.js >= 14.0.0
+
+## License
+
+MIT © Sebastian Schepis
+
+## Contributing
+
+Contributions welcome! Please read the documentation in `docs/` before submitting PRs.

package/backends/cryptographic/index.js

@@ -0,0 +1,196 @@
+/**
+ * Cryptographic Backend - Prime-based hashing, encryption, and key derivation
+ */
+const { Backend } = require('../interface');
+const { Hypercomplex } = require('../../core/hypercomplex');
+const { GaussianInteger, primeToFrequency, isPrime, firstNPrimes } = require('../../core/prime');
+
+class CryptographicBackend extends Backend {
+  constructor(config) {
+    super(config);
+    this.dimension = config.dimension || 32;  // Higher dimension for security
+    this.keyPrimes = config.keyPrimes || this.generateKeyPrimes(256);
+    this.config.primes = this.keyPrimes;
+    this.transforms = config.transforms || this.generateDefaultTransforms();
+    this.rounds = config.rounds || 16;
+  }
+  
+  generateKeyPrimes(count) {
+    return firstNPrimes(count);
+  }
+  
+  generateDefaultTransforms() {
+    // Generate mixing transforms for cryptographic operations
+    const transforms = [];
+    for (let i = 0; i < 16; i++) {
+      transforms.push({
+        n: `mix_${i}`,
+        key: this.keyPrimes.slice(i * 4, i * 4 + 4)
+      });
+    }
+    return transforms;
+  }
+  
+  encode(input) {
+    const bytes = typeof input === 'string' 
+      ? Buffer.from(input, 'utf8') 
+      : Buffer.isBuffer(input) 
+        ? input 
+        : Buffer.from(input);
+    return [...bytes].map(b => this.keyPrimes[b % this.keyPrimes.length]);
+  }
+  
+  decode(primes) {
+    const primeToIndex = new Map(this.keyPrimes.map((p, i) => [p, i]));
+    const bytes = primes.map(p => primeToIndex.get(p) || 0);
+    return Buffer.from(bytes);
+  }
+  
+  primesToState(primes) {
+    const state = Hypercomplex.zero(this.dimension);
+    for (let i = 0; i < primes.length; i++) {
+      const p = primes[i];
+      const angle = (2 * Math.PI * p) / this.dimension;
+      const idx = i % this.dimension;
+      
+      // Use Gaussian integer decomposition for primes ≡ 1 (mod 4)
+      if (p % 4 === 1) {
+        const gi = new GaussianInteger(Math.cos(angle), Math.sin(angle));
+        state.c[idx] += gi.real / Math.sqrt(primes.length || 1);
+        state.c[(idx + 1) % this.dimension] += gi.imag / Math.sqrt(primes.length || 1);
+      } else {
+        state.c[idx] += Math.cos(angle * p) / Math.sqrt(primes.length || 1);
+      }
+    }
+    return state.normalize();
+  }
+  
+  primesToFrequencies(primes) {
+    // Use tighter frequency range for cryptographic mixing
+    return primes.map(p => primeToFrequency(p, 1, 5));
+  }
+  
+  applyTransform(inputPrimes, transform) {
+    const key = transform.key || [2, 3, 5, 7];
+    return inputPrimes.map((p, i) => {
+      const k = key[i % key.length];
+      const product = p * k;
+      return this.keyPrimes[product % this.keyPrimes.length];
+    });
+  }
+  
+  /**
+   * Hash input using hypercomplex state mixing
+   */
+  hash(input, outputLength = 32) {
+    const primes = this.encode(input);
+    let state = this.primesToState(primes);
+    
+    // Create input-dependent mixing constants
+    const inputSum = primes.reduce((a, b) => a + b, 0);
+    const inputXor = primes.reduce((a, b) => a ^ b, 0);
+    
+    // Multiple rounds of mixing
+    for (let i = 0; i < this.rounds; i++) {
+      // Mix with shifted version of self for non-commutativity
+      const shifted = Hypercomplex.zero(this.dimension);
+      for (let j = 0; j < this.dimension; j++) {
+        shifted.c[(j + i + 1) % this.dimension] = state.c[j];
+      }
+      
+      // Combine original and shifted
+      state = state.mul(shifted).normalize();
+      
+      // Add input-dependent round constant
+      const roundConst = Hypercomplex.zero(this.dimension);
+      const idx = (i + inputXor) % this.dimension;
+      roundConst.c[idx] = 0.1 * Math.sin(inputSum + i);
+      roundConst.c[(idx + 7) % this.dimension] = 0.1 * Math.cos(inputSum + i);
+      state = state.add(roundConst).normalize();
+      
+      // Non-linear transformation
+      for (let j = 0; j < this.dimension; j++) {
+        state.c[j] = Math.tanh(state.c[j] * 2);
+      }
+      state = state.normalize();
+    }
+    
+    // Extract hash bytes from state with input-dependent scrambling
+    const hashBytes = [];
+    for (let i = 0; i < outputLength; i++) {
+      const idx = (i + inputXor) % this.dimension;
+      const val = Math.abs(state.c[idx] * 127.5 + state.c[(idx + 1) % this.dimension] * 127.5);
+      hashBytes.push(Math.floor(val) & 0xFF);
+    }
+    return Buffer.from(hashBytes);
+  }
+  
+  /**
+   * Derive key from password using salt and iterations
+   */
+  deriveKey(password, salt, keyLength = 32, iterations = 10000) {
+    let primes = this.encode(password);
+    const saltPrimes = this.encode(salt);
+    
+    for (let i = 0; i < iterations; i++) {
+      // Mix password and salt primes
+      primes = [...primes, ...saltPrimes];
+      const state = this.primesToState(primes);
+      
+      // Apply iteration-dependent mixing
+      const mixed = state.mul(Hypercomplex.fromReal(this.dimension, i + 1));
+      
+      // Extract new primes from mixed state
+      primes = [];
+      for (let j = 0; j < this.dimension; j++) {
+        const idx = Math.floor(Math.abs(mixed.c[j]) * this.keyPrimes.length);
+        primes.push(this.keyPrimes[idx % this.keyPrimes.length]);
+      }
+    }
+    
+    return this.hash(Buffer.from(primes), keyLength);
+  }
+  
+  /**
+   * Generate random primes for key material
+   */
+  generateRandomPrimes(count) {
+    const primes = [];
+    for (let i = 0; i < count; i++) {
+      const idx = Math.floor(Math.random() * this.keyPrimes.length);
+      primes.push(this.keyPrimes[idx]);
+    }
+    return primes;
+  }
+  
+  /**
+   * XOR-style prime mixing for encryption
+   */
+  mixPrimes(dataPrimes, keyPrimes) {
+    return dataPrimes.map((p, i) => {
+      const k = keyPrimes[i % keyPrimes.length];
+      const mixed = (p * k) % (this.keyPrimes[this.keyPrimes.length - 1] + 1);
+      // Find nearest prime
+      let result = this.keyPrimes.find(q => q >= mixed) || this.keyPrimes[0];
+      return result;
+    });
+  }
+  
+  /**
+   * Compute HMAC-like authentication code
+   */
+  hmac(key, message, outputLength = 32) {
+    const keyPrimes = this.encode(key);
+    const msgPrimes = this.encode(message);
+    
+    // Inner hash
+    const innerPrimes = this.mixPrimes(msgPrimes, keyPrimes);
+    const innerHash = this.hash(Buffer.from(innerPrimes), this.dimension);
+    
+    // Outer hash
+    const outerPrimes = this.mixPrimes(this.encode(innerHash), keyPrimes);
+    return this.hash(Buffer.from(outerPrimes), outputLength);
+  }
+}
+
+module.exports = { CryptographicBackend };

package/backends/index.js

@@ -0,0 +1,15 @@
+/**
+ * Backends - exports all domain backends
+ */
+
+const { Backend } = require('./interface');
+const { SemanticBackend } = require('./semantic');
+const { CryptographicBackend } = require('./cryptographic');
+const { ScientificBackend } = require('./scientific');
+
+module.exports = {
+  Backend,
+  SemanticBackend,
+  CryptographicBackend,
+  ScientificBackend
+};

package/backends/interface.js

@@ -0,0 +1,89 @@
+/**
+ * Common interface for all domain backends
+ */
+class Backend {
+  constructor(config) {
+    this.config = config;
+    this.dimension = config.dimension || 16;
+  }
+  
+  /**
+   * Encode domain-specific input into prime representation
+   * @param {*} input - Domain-specific input
+   * @returns {number[]} Array of primes
+   */
+  encode(input) { 
+    throw new Error('Backend.encode() must be implemented'); 
+  }
+  
+  /**
+   * Decode prime representation back to domain-specific output
+   * @param {number[]} primes - Array of primes
+   * @returns {*} Domain-specific output
+   */
+  decode(primes) { 
+    throw new Error('Backend.decode() must be implemented'); 
+  }
+  
+  /**
+   * Convert primes to hypercomplex state vector
+   * @param {number[]} primes - Array of primes
+   * @returns {Hypercomplex} State vector
+   */
+  primesToState(primes) { 
+    throw new Error('Backend.primesToState() must be implemented'); 
+  }
+  
+  /**
+   * Convert primes to oscillator frequencies
+   * @param {number[]} primes - Array of primes
+   * @returns {number[]} Array of frequencies
+   */
+  primesToFrequencies(primes) { 
+    throw new Error('Backend.primesToFrequencies() must be implemented'); 
+  }
+  
+  /**
+   * Apply a domain-specific transform to primes
+   * @param {number[]} inputPrimes - Input primes
+   * @param {object} transform - Transform specification
+   * @returns {number[]} Transformed primes
+   */
+  applyTransform(inputPrimes, transform) { 
+    throw new Error('Backend.applyTransform() must be implemented'); 
+  }
+  
+  /**
+   * Get available transforms
+   * @returns {object[]} Array of transform specifications
+   */
+  getTransforms() { 
+    return this.config.transforms || []; 
+  }
+  
+  /**
+   * Get prime list used by this backend
+   * @returns {number[]} Array of primes
+   */
+  getPrimes() { 
+    return this.config.primes; 
+  }
+  
+  /**
+   * Get semantic axes (for backends that use them)
+   * @returns {object} Axes mapping
+   */
+  getAxes() { 
+    return this.config.axes; 
+  }
+  
+  /**
+   * Get backend name/type
+   * @returns {string}
+   */
+  getName() {
+    return this.constructor.name;
+  }
+}
+
+module.exports = { Backend };