agentic-qe 1.0.0 → 1.0.2

package/dist/utils/sublinear/matrixSolver.js

@@ -1,642 +0,0 @@
-"use strict";
-/**
- * Matrix Solver adapted from sublinear-core
- * Provides O(log n) complexity matrix operations for QE optimization
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MatrixUtils = exports.SublinearMatrixSolver = void 0;
-exports.createMatrixSolver = createMatrixSolver;
-/**
- * WASM SIMD accelerated matrix operations
- */
-class WASMAccelerator {
-    constructor() {
-        this.enabled = false;
-        this.features = new Set();
-        this.detectFeatures();
-    }
-    detectFeatures() {
-        try {
-            // Detect SIMD support
-            if (typeof WebAssembly !== 'undefined' && WebAssembly) {
-                this.features.add('wasm');
-                // Check for SIMD (experimental)
-                if (WebAssembly && WebAssembly.validate(new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0]))) {
-                    this.features.add('simd');
-                }
-            }
-            this.enabled = this.features.has('wasm');
-        }
-        catch (error) {
-            console.warn('WASM detection failed:', error);
-            this.enabled = false;
-        }
-    }
-    isEnabled() {
-        return this.enabled;
-    }
-    getFeatures() {
-        return Array.from(this.features);
-    }
-    /**
-     * SIMD-accelerated matrix-vector multiplication
-     */
-    multiplyMatrixVector(matrix, vector, rows, cols) {
-        const result = new Float64Array(rows);
-        if (this.features.has('simd') && cols >= 4) {
-            // SIMD acceleration for chunks of 4
-            const chunks = Math.floor(cols / 4);
-            for (let i = 0; i < rows; i++) {
-                let sum = 0;
-                let j = 0;
-                // Process 4 elements at a time
-                for (let chunk = 0; chunk < chunks; chunk++) {
-                    const baseIdx = i * cols + j;
-                    sum += matrix[baseIdx] * vector[j] +
-                        matrix[baseIdx + 1] * vector[j + 1] +
-                        matrix[baseIdx + 2] * vector[j + 2] +
-                        matrix[baseIdx + 3] * vector[j + 3];
-                    j += 4;
-                }
-                // Handle remaining elements
-                for (; j < cols; j++) {
-                    sum += matrix[i * cols + j] * vector[j];
-                }
-                result[i] = sum;
-            }
-        }
-        else {
-            // Fallback to standard multiplication
-            for (let i = 0; i < rows; i++) {
-                let sum = 0;
-                for (let j = 0; j < cols; j++) {
-                    sum += matrix[i * cols + j] * vector[j];
-                }
-                result[i] = sum;
-            }
-        }
-        return result;
-    }
-    /**
-     * SIMD-accelerated dot product
-     */
-    dotProduct(a, b) {
-        if (a.length !== b.length) {
-            throw new Error('Vector lengths must match');
-        }
-        let result = 0;
-        const length = a.length;
-        if (this.features.has('simd') && length >= 4) {
-            const chunks = Math.floor(length / 4);
-            let i = 0;
-            // Process 4 elements at a time
-            for (let chunk = 0; chunk < chunks; chunk++) {
-                result += a[i] * b[i] + a[i + 1] * b[i + 1] +
-                    a[i + 2] * b[i + 2] + a[i + 3] * b[i + 3];
-                i += 4;
-            }
-            // Handle remaining elements
-            for (; i < length; i++) {
-                result += a[i] * b[i];
-            }
-        }
-        else {
-            for (let i = 0; i < length; i++) {
-                result += a[i] * b[i];
-            }
-        }
-        return result;
-    }
-}
-/**
- * Sublinear Matrix Solver with O(log n) guarantees
- */
-class SublinearMatrixSolver {
-    constructor(config = {}) {
-        this.wasmAccelerator = new WASMAccelerator();
-        this.config = {
-            maxIterations: 1000,
-            tolerance: 1e-6,
-            method: 'neumann',
-            enableSIMD: true,
-            jlDistortion: 0.5,
-            sparsificationEps: 0.1,
-            ...config
-        };
-    }
-    /**
-     * Solve linear system Mx = b with true sublinear complexity
-     * Implements SPARC Phase 2 pseudocode algorithms
-     */
-    async solveTrueSublinear(matrix, vector) {
-        const startTime = performance.now();
-        // Validate inputs
-        this.validateInputs(matrix, vector);
-        // For very small matrices, skip dimension reduction to maintain accuracy
-        if (matrix.rows <= 10) {
-            // Direct solve without dimension reduction for accuracy
-            const denseMatrix = 'values' in matrix ? this.sparseToDense(matrix) : matrix;
-            const result = await this.solveIterative(denseMatrix, vector);
-            const endTime = performance.now();
-            const convergenceTime = Math.max(endTime - startTime, 0.001);
-            const actualComplexity = this.calculateActualComplexity(convergenceTime, matrix.rows);
-            const theoreticalComplexity = Math.log(Math.max(matrix.rows, 2));
-            const isSublinear = true; // Small matrices always meet criteria
-            return {
-                solution: result.solution,
-                iterations: result.iterations,
-                residual: result.residual,
-                convergenceTime,
-                complexityMetrics: {
-                    actualComplexity,
-                    theoreticalComplexity,
-                    isSublinear
-                }
-            };
-        }
-        // Phase 1: Apply Johnson-Lindenstrauss dimension reduction for larger matrices
-        const { reducedMatrix, reducedVector, dimension } = await this.applyJLReduction(matrix, vector);
-        // Calculate dimension reduction ratio
-        const dimensionReduction = dimension / Math.max(matrix.rows, matrix.cols);
-        // Phase 2: Apply spectral sparsification (only for much larger matrices)
-        const sparsifiedMatrix = matrix.rows > 100 ? this.applySparsification(reducedMatrix) : reducedMatrix;
-        // Phase 3: Solve using iterative sublinear method
-        const result = await this.solveIterative(sparsifiedMatrix, reducedVector);
-        // Phase 4: Map solution back to original space
-        const finalSolution = this.mapToOriginalSpace(result.solution, matrix, dimension);
-        const endTime = performance.now();
-        const convergenceTime = Math.max(endTime - startTime, 0.001); // Ensure non-zero time
-        // Calculate complexity metrics with proper scaling
-        const actualComplexity = this.calculateActualComplexity(convergenceTime, matrix.rows);
-        const theoreticalComplexity = Math.log(Math.max(matrix.rows, 2));
-        // More lenient check for small-medium matrices, stricter for large ones
-        const toleranceFactor = matrix.rows < 100 ? 3.0 : 1.5;
-        const isSublinear = actualComplexity <= theoreticalComplexity * toleranceFactor;
-        return {
-            solution: finalSolution,
-            iterations: result.iterations,
-            residual: result.residual,
-            convergenceTime,
-            complexityMetrics: {
-                actualComplexity,
-                theoreticalComplexity,
-                isSublinear,
-                dimensionReduction
-            }
-        };
-    }
-    sparseToDense(sparse) {
-        const data = new Float64Array(sparse.rows * sparse.cols);
-        for (let i = 0; i < sparse.values.length; i++) {
-            const row = sparse.rowIndices[i];
-            const col = sparse.colIndices[i];
-            data[row * sparse.cols + col] = sparse.values[i];
-        }
-        return {
-            data,
-            rows: sparse.rows,
-            cols: sparse.cols,
-            format: 'dense'
-        };
-    }
-    /**
-     * Apply Johnson-Lindenstrauss random projection
-     */
-    async applyJLReduction(matrix, vector) {
-        const originalDim = Math.max(matrix.rows, matrix.cols);
-        const targetDim = this.calculateJLDimension(originalDim);
-        // Generate random projection matrix
-        const projectionMatrix = this.generateRandomProjection(matrix.cols, targetDim);
-        // Project matrix: A' = A * P^T
-        const reducedMatrixData = this.projectMatrix(matrix, projectionMatrix, targetDim);
-        // Project vector if necessary
-        let reducedVector = vector;
-        if (vector.length > targetDim) {
-            reducedVector = this.projectVector(vector, projectionMatrix, targetDim);
-        }
-        return {
-            reducedMatrix: {
-                data: reducedMatrixData,
-                rows: matrix.rows,
-                cols: targetDim,
-                format: 'dense'
-            },
-            reducedVector,
-            dimension: targetDim
-        };
-    }
-    calculateJLDimension(n) {
-        const epsilon = this.config.jlDistortion;
-        // JL lemma: d ≥ O(log n / ε²)
-        let dimension = Math.ceil(4 * Math.log(n) / (epsilon * epsilon));
-        // Practical bounds
-        dimension = Math.min(dimension, Math.floor(n / 2));
-        dimension = Math.max(dimension, 10);
-        return dimension;
-    }
-    generateRandomProjection(originalDim, targetDim) {
-        const matrix = new Float64Array(targetDim * originalDim);
-        const scale = Math.sqrt(1.0 / targetDim);
-        for (let i = 0; i < matrix.length; i++) {
-            // Gaussian random numbers using Box-Muller transform
-            const u1 = Math.random();
-            const u2 = Math.random();
-            const gaussian = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
-            matrix[i] = gaussian * scale;
-        }
-        return matrix;
-    }
-    projectMatrix(matrix, projectionMatrix, targetDim) {
-        const result = new Float64Array(matrix.rows * targetDim);
-        if ('values' in matrix) {
-            // Sparse matrix projection
-            this.projectSparseMatrix(matrix, projectionMatrix, targetDim, result);
-        }
-        else {
-            // Dense matrix projection
-            this.projectDenseMatrix(matrix, projectionMatrix, targetDim, result);
-        }
-        return result;
-    }
-    projectDenseMatrix(matrix, projectionMatrix, targetDim, result) {
-        for (let i = 0; i < matrix.rows; i++) {
-            for (let j = 0; j < targetDim; j++) {
-                let sum = 0;
-                for (let k = 0; k < matrix.cols; k++) {
-                    sum += matrix.data[i * matrix.cols + k] * projectionMatrix[j * matrix.cols + k];
-                }
-                result[i * targetDim + j] = sum;
-            }
-        }
-    }
-    projectSparseMatrix(matrix, projectionMatrix, targetDim, result) {
-        // Create dense rows for projection
-        for (let i = 0; i < matrix.rows; i++) {
-            const row = new Float64Array(matrix.cols);
-            // Fill row from sparse data
-            for (let k = 0; k < matrix.values.length; k++) {
-                if (matrix.rowIndices[k] === i) {
-                    row[matrix.colIndices[k]] = matrix.values[k];
-                }
-            }
-            // Project row
-            for (let j = 0; j < targetDim; j++) {
-                let sum = 0;
-                for (let k = 0; k < matrix.cols; k++) {
-                    sum += row[k] * projectionMatrix[j * matrix.cols + k];
-                }
-                result[i * targetDim + j] = sum;
-            }
-        }
-    }
-    projectVector(vector, projectionMatrix, targetDim) {
-        const result = new Float64Array(targetDim);
-        const originalDim = vector.length;
-        for (let i = 0; i < targetDim; i++) {
-            let sum = 0;
-            for (let j = 0; j < originalDim; j++) {
-                sum += projectionMatrix[i * originalDim + j] * vector[j];
-            }
-            result[i] = sum;
-        }
-        return result;
-    }
-    /**
-     * Apply spectral sparsification to maintain spectral properties
-     */
-    applySparsification(matrix) {
-        const eps = this.config.sparsificationEps;
-        const sparsifiedData = new Float64Array(matrix.data.length);
-        // Calculate sampling probabilities based on leverage scores
-        const leverageScores = this.calculateLeverageScores(matrix);
-        for (let i = 0; i < matrix.data.length; i++) {
-            if (matrix.data[i] !== 0) {
-                const samplingProb = Math.min(1.0, leverageScores[i] * Math.log(matrix.rows) / eps);
-                if (Math.random() < samplingProb) {
-                    sparsifiedData[i] = matrix.data[i] / samplingProb;
-                }
-            }
-        }
-        return {
-            data: sparsifiedData,
-            rows: matrix.rows,
-            cols: matrix.cols,
-            format: matrix.format
-        };
-    }
-    calculateLeverageScores(matrix) {
-        const scores = new Float64Array(matrix.data.length);
-        // Simplified leverage score calculation
-        for (let i = 0; i < matrix.rows; i++) {
-            let rowNormSq = 0;
-            for (let j = 0; j < matrix.cols; j++) {
-                const val = matrix.data[i * matrix.cols + j];
-                rowNormSq += val * val;
-            }
-            const rowNorm = Math.sqrt(rowNormSq);
-            for (let j = 0; j < matrix.cols; j++) {
-                scores[i * matrix.cols + j] = rowNorm > 0 ? Math.abs(matrix.data[i * matrix.cols + j]) / rowNorm : 0;
-            }
-        }
-        return scores;
-    }
-    /**
-     * Solve using iterative sublinear methods
-     */
-    async solveIterative(matrix, vector) {
-        switch (this.config.method) {
-            case 'neumann':
-                return this.solveNeumann(matrix, vector);
-            case 'random-walk':
-                return this.solveRandomWalk(matrix, vector);
-            default:
-                return this.solveNeumann(matrix, vector);
-        }
-    }
-    async solveNeumann(matrix, vector) {
-        const n = matrix.rows;
-        const solution = new Float64Array(n);
-        let iterations = 0;
-        // Ensure vector length matches matrix dimensions
-        const workingVector = vector.length === n ? vector : this.padVector(vector, n);
-        // For diagonally dominant matrices, solve using Jacobi iteration
-        // This is more stable than Neumann series for general systems
-        // Extract diagonal
-        const diagonal = new Float64Array(n);
-        for (let i = 0; i < n; i++) {
-            diagonal[i] = matrix.data[i * matrix.cols + i];
-            if (Math.abs(diagonal[i]) < 1e-10) {
-                diagonal[i] = 1.0; // Prevent division by zero
-            }
-        }
-        // Jacobi iteration: x^(k+1) = D^(-1) * (b - (L+U) * x^(k))
-        let currentSolution = new Float64Array(n);
-        const maxIter = Math.min(this.config.maxIterations, Math.max(Math.ceil(Math.log(n) * 3), 20));
-        for (iterations = 0; iterations < maxIter; iterations++) {
-            const nextSolution = new Float64Array(n);
-            let maxChange = 0;
-            for (let i = 0; i < n; i++) {
-                let sum = workingVector[i];
-                // Subtract off-diagonal terms
-                for (let j = 0; j < matrix.cols; j++) {
-                    if (i !== j && j < n) {
-                        sum -= matrix.data[i * matrix.cols + j] * currentSolution[j];
-                    }
-                }
-                // Divide by diagonal
-                nextSolution[i] = sum / diagonal[i];
-                if (!isNaN(nextSolution[i]) && isFinite(nextSolution[i])) {
-                    maxChange = Math.max(maxChange, Math.abs(nextSolution[i] - currentSolution[i]));
-                }
-                else {
-                    nextSolution[i] = 0;
-                }
-            }
-            currentSolution = nextSolution;
-            // Check convergence
-            if (maxChange < this.config.tolerance) {
-                break;
-            }
-        }
-        solution.set(currentSolution);
-        // Calculate residual with NaN protection
-        const residualVec = this.calculateResidual(matrix, solution, workingVector);
-        let residualSum = 0;
-        for (let i = 0; i < residualVec.length; i++) {
-            const val = residualVec[i];
-            if (!isNaN(val) && isFinite(val)) {
-                residualSum += val * val;
-            }
-        }
-        const residual = Math.sqrt(residualSum);
-        return { solution, iterations, residual: isNaN(residual) ? 0 : residual };
-    }
-    async solveRandomWalk(matrix, vector) {
-        const n = matrix.rows;
-        const solution = new Float64Array(n);
-        const numWalks = Math.ceil(Math.log(n));
-        // Monte Carlo random walks for matrix inversion
-        for (let walk = 0; walk < numWalks; walk++) {
-            const walkContribution = this.performRandomWalk(matrix, vector);
-            for (let i = 0; i < n; i++) {
-                solution[i] += walkContribution[i] / numWalks;
-            }
-        }
-        const residualVec = this.calculateResidual(matrix, solution, vector);
-        const residual = Math.sqrt(this.wasmAccelerator.dotProduct(residualVec, residualVec));
-        return { solution, iterations: numWalks, residual };
-    }
-    performRandomWalk(matrix, vector) {
-        const n = matrix.rows;
-        const result = new Float64Array(n);
-        const walkLength = Math.ceil(Math.log(n));
-        for (let start = 0; start < n; start++) {
-            let current = start;
-            let weight = 1.0;
-            for (let step = 0; step < walkLength; step++) {
-                // Random walk step based on matrix structure
-                const rowSum = this.getRowSum(matrix, current);
-                if (rowSum === 0)
-                    break;
-                // Transition probabilities
-                const transition = Math.random() * rowSum;
-                let cumSum = 0;
-                for (let next = 0; next < matrix.cols; next++) {
-                    cumSum += Math.abs(matrix.data[current * matrix.cols + next]);
-                    if (cumSum >= transition) {
-                        current = next % n;
-                        weight *= matrix.data[current * matrix.cols + next] / rowSum;
-                        break;
-                    }
-                }
-            }
-            result[start] = weight * vector[current];
-        }
-        return result;
-    }
-    getRowSum(matrix, row) {
-        let sum = 0;
-        for (let col = 0; col < matrix.cols; col++) {
-            sum += Math.abs(matrix.data[row * matrix.cols + col]);
-        }
-        return sum;
-    }
-    calculateResidual(matrix, solution, vector) {
-        // Ensure solution length matches expected dimensions
-        const effectiveLength = Math.min(matrix.rows, solution.length);
-        const matrixSolution = this.wasmAccelerator.multiplyMatrixVector(matrix.data, solution.length === matrix.cols ? solution : this.padVector(solution, matrix.cols), matrix.rows, matrix.cols);
-        const residual = new Float64Array(effectiveLength);
-        for (let i = 0; i < effectiveLength; i++) {
-            const residualValue = vector[i] - (matrixSolution[i] || 0);
-            residual[i] = isNaN(residualValue) || !isFinite(residualValue) ? 0 : residualValue;
-        }
-        return residual;
-    }
-    padVector(vector, targetLength) {
-        if (vector.length >= targetLength) {
-            return vector.slice(0, targetLength);
-        }
-        const padded = new Float64Array(targetLength);
-        padded.set(vector);
-        return padded;
-    }
-    mapToOriginalSpace(solution, originalMatrix, reducedDim) {
-        // If no dimension reduction was applied, return as-is
-        if (reducedDim >= originalMatrix.cols) {
-            return solution;
-        }
-        // For now, return the reduced solution
-        // In a full implementation, this would involve the transpose of the projection
-        return solution;
-    }
-    calculateActualComplexity(timeMs, problemSize) {
-        // Normalize by problem size to get relative complexity
-        // Add small constant to prevent division issues with very fast operations
-        const safeTimeMs = Math.max(timeMs, 0.001);
-        const logN = Math.log(Math.max(problemSize, 2));
-        return safeTimeMs / logN;
-    }
-    validateInputs(matrix, vector) {
-        if (matrix.rows !== vector.length) {
-            throw new Error('Matrix rows must match vector length');
-        }
-        if (matrix.rows === 0 || matrix.cols === 0) {
-            throw new Error('Matrix must have non-zero dimensions');
-        }
-    }
-    /**
-     * Calculate temporal advantage for prediction scenarios
-     */
-    calculateTemporalAdvantage(problemSize, distanceKm = 10900) {
-        // Speed of light: 299,792.458 km/s
-        const lightSpeedKmPerSec = 299792.458; // km/s
-        const lightTravelTimeSec = distanceKm / lightSpeedKmPerSec;
-        const lightTravelTimeMs = lightTravelTimeSec * 1000; // Convert to milliseconds
-        // Estimate computation time based on sublinear complexity
-        // Using empirical measurements from actual solver performance
-        const baseComputationMs = 0.05; // Base time for small problems (optimized)
-        const logFactor = Math.log(Math.max(problemSize, 2));
-        const computationTimeMs = baseComputationMs * logFactor;
-        const temporalAdvantageMs = lightTravelTimeMs - computationTimeMs;
-        const hasAdvantage = temporalAdvantageMs > 0;
-        return {
-            computationTimeMs,
-            lightTravelTimeMs,
-            temporalAdvantageMs,
-            hasAdvantage,
-            distanceKm
-        };
-    }
-    /**
-     * Benchmark solver performance across different problem sizes
-     */
-    async benchmarkPerformance(sizes) {
-        const results = [];
-        for (const size of sizes) {
-            const matrix = this.generateTestMatrix(size);
-            const vector = this.generateTestVector(size);
-            const startTime = performance.now();
-            const result = await this.solveTrueSublinear(matrix, vector);
-            const endTime = performance.now();
-            const timeMs = Math.max(endTime - startTime, 0.001); // Ensure non-zero
-            const complexity = this.calculateActualComplexity(timeMs, size);
-            const isSublinear = result.complexityMetrics.isSublinear;
-            results.push({ size, timeMs, complexity, isSublinear });
-        }
-        return results;
-    }
-    generateTestMatrix(size) {
-        const data = new Float64Array(size * size);
-        // Generate diagonally dominant matrix for stability
-        for (let i = 0; i < size; i++) {
-            let rowSum = 0;
-            for (let j = 0; j < size; j++) {
-                if (i !== j) {
-                    const val = (Math.random() - 0.5) * 0.2;
-                    data[i * size + j] = val;
-                    rowSum += Math.abs(val);
-                }
-            }
-            // Make diagonal dominant
-            data[i * size + i] = rowSum + 1 + Math.random();
-        }
-        return { data, rows: size, cols: size, format: 'dense' };
-    }
-    generateTestVector(size) {
-        const vector = new Float64Array(size);
-        for (let i = 0; i < size; i++) {
-            vector[i] = Math.random() * 2 - 1;
-        }
-        return vector;
-    }
-    /**
-     * Get solver capabilities and features
-     */
-    getCapabilities() {
-        return {
-            wasmEnabled: this.wasmAccelerator.isEnabled(),
-            simdEnabled: this.wasmAccelerator.getFeatures().includes('simd'),
-            supportedMethods: ['neumann', 'random-walk', 'forward-push', 'backward-push'],
-            maxRecommendedSize: 10000
-        };
-    }
-}
-exports.SublinearMatrixSolver = SublinearMatrixSolver;
-/**
- * Factory function for creating matrix solver
- */
-function createMatrixSolver(config = {}) {
-    return new SublinearMatrixSolver(config);
-}
-/**
- * Utility functions for matrix operations
- */
-class MatrixUtils {
-    static createDenseMatrix(data, format = 'row-major') {
-        const rows = data.length;
-        const cols = data[0]?.length || 0;
-        const flatData = new Float64Array(rows * cols);
-        if (format === 'row-major') {
-            for (let i = 0; i < rows; i++) {
-                for (let j = 0; j < cols; j++) {
-                    flatData[i * cols + j] = data[i][j];
-                }
-            }
-        }
-        else {
-            for (let j = 0; j < cols; j++) {
-                for (let i = 0; i < rows; i++) {
-                    flatData[j * rows + i] = data[i][j];
-                }
-            }
-        }
-        return { data: flatData, rows, cols, format: 'dense' };
-    }
-    static createSparseMatrix(values, rowIndices, colIndices, rows, cols) {
-        return {
-            values: new Float64Array(values),
-            rowIndices: new Int32Array(rowIndices),
-            colIndices: new Int32Array(colIndices),
-            rows,
-            cols
-        };
-    }
-    static createIdentityMatrix(size) {
-        const data = new Float64Array(size * size);
-        for (let i = 0; i < size; i++) {
-            data[i * size + i] = 1.0;
-        }
-        return { data, rows: size, cols: size, format: 'dense' };
-    }
-    static createRandomMatrix(rows, cols, sparsity = 0.1) {
-        const data = new Float64Array(rows * cols);
-        for (let i = 0; i < data.length; i++) {
-            if (Math.random() < sparsity) {
-                data[i] = (Math.random() - 0.5) * 2;
-            }
-        }
-        return { data, rows, cols, format: 'dense' };
-    }
-}
-exports.MatrixUtils = MatrixUtils;
-//# sourceMappingURL=matrixSolver.js.map