mirror of
https://github.com/ruvnet/RuView
synced 2026-08-09 20:21:43 +00:00
feat: vendor midstream and sublinear-time-solver libraries
Add ruvnet/midstream (AIMDS real-time inference) and ruvnet/sublinear-time-solver (sublinear optimization algorithms) as vendored dependencies under vendor/. Co-Authored-By: claude-flow <ruv@ruv.net>
This commit is contained in:
ruv
+283
@@ -0,0 +1,283 @@
|
||||
#!/usr/bin/env node
|
||||
|
||||
/**
|
||||
* Temporal Matrix Solver Demo
|
||||
*
|
||||
* Demonstrates solving matrix problems before data arrives using
|
||||
* the Strange Loops + Sublinear Solver integration
|
||||
*/
|
||||
|
||||
const SublinearStrangeLoops = require('../lib/sublinear-integration');
|
||||
const chalk = require('chalk');
|
||||
const ora = require('ora');
|
||||
const { table } = require('table');
|
||||
|
||||
async function main() {
|
||||
console.log(chalk.cyan.bold('\n╔══════════════════════════════════════════════════════════╗'));
|
||||
console.log(chalk.cyan.bold('║ TEMPORAL MATRIX SOLVER - COMPUTING BEFORE DATA ARRIVES ║'));
|
||||
console.log(chalk.cyan.bold('╚══════════════════════════════════════════════════════════╝\n'));
|
||||
|
||||
const system = new SublinearStrangeLoops();
|
||||
|
||||
// ============================================================================
|
||||
// DEMO 1: Basic Temporal Advantage
|
||||
// ============================================================================
|
||||
console.log(chalk.yellow('\n📡 Demo 1: Tokyo to NYC - Solving Before Light Arrives\n'));
|
||||
|
||||
const spinner1 = ora('Creating temporal solver swarm...').start();
|
||||
|
||||
try {
|
||||
// Create solver for Tokyo-NYC distance
|
||||
const { solverId, temporalAdvantage, agentConfiguration } =
|
||||
await system.createTemporalSolverSwarm({
|
||||
agentCount: 1000,
|
||||
matrixSize: 1000,
|
||||
distanceKm: 10900, // Tokyo to NYC
|
||||
topology: 'hierarchical'
|
||||
});
|
||||
|
||||
spinner1.succeed('Temporal solver swarm created!');
|
||||
|
||||
console.log(chalk.white('\n📊 Temporal Advantage Configuration:'));
|
||||
const configData = [
|
||||
['Distance', `${10900} km (Tokyo → NYC)`],
|
||||
['Light Travel Time', `${temporalAdvantage.lightTravelTimeMs} ms`],
|
||||
['Sublinear Compute Time', `${temporalAdvantage.sublinearTimeMs} ms`],
|
||||
['Temporal Advantage', chalk.green(`${temporalAdvantage.advantageMs} ms`)],
|
||||
['Can Solve Before Arrival', temporalAdvantage.canSolveBeforeArrival ? chalk.green('✅ YES') : chalk.red('❌ NO')]
|
||||
];
|
||||
|
||||
console.log(table(configData, {
|
||||
border: {
|
||||
topBody: '─',
|
||||
topJoin: '┬',
|
||||
topLeft: '┌',
|
||||
topRight: '┐',
|
||||
bottomBody: '─',
|
||||
bottomJoin: '┴',
|
||||
bottomLeft: '└',
|
||||
bottomRight: '┘',
|
||||
bodyLeft: '│',
|
||||
bodyRight: '│',
|
||||
bodyJoin: '│',
|
||||
joinBody: '─',
|
||||
joinLeft: '├',
|
||||
joinRight: '┤',
|
||||
joinJoin: '┼'
|
||||
}
|
||||
}));
|
||||
|
||||
// Generate test problem
|
||||
const matrix = system.generateDiagonallyDominantMatrix(1000);
|
||||
const vector = Array(1000).fill(0).map(() => Math.random());
|
||||
|
||||
const spinner2 = ora('Solving matrix with temporal advantage...').start();
|
||||
|
||||
const result = await system.solveWithTemporalAdvantage(solverId, matrix, vector);
|
||||
|
||||
spinner2.succeed('Matrix solved!');
|
||||
|
||||
console.log(chalk.white('\n⚡ Solving Results:'));
|
||||
const resultsData = [
|
||||
['Computation Time', `${result.timing.computationTimeMs} ms`],
|
||||
['Light Travel Time', `${result.timing.lightTravelTimeMs} ms`],
|
||||
['Temporal Advantage Used', `${result.timing.temporalAdvantageMs} ms`],
|
||||
['Solved Before Data Arrival', result.timing.solvedBeforeDataArrival ? chalk.green('✅ YES') : chalk.red('❌ NO')],
|
||||
['Solution Quality', `${(result.quality.confidence * 100).toFixed(1)}% confidence`],
|
||||
['Agent Throughput', result.agentMetrics.throughput]
|
||||
];
|
||||
|
||||
console.log(table(resultsData));
|
||||
|
||||
} catch (error) {
|
||||
spinner1.fail('Demo 1 failed: ' + error.message);
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// DEMO 2: Validation Across Multiple Scenarios
|
||||
// ============================================================================
|
||||
console.log(chalk.yellow('\n🔬 Demo 2: Validating Temporal Advantage\n'));
|
||||
|
||||
const spinner3 = ora('Running validation across multiple configurations...').start();
|
||||
|
||||
try {
|
||||
const validation = await system.validateTemporalAdvantage({
|
||||
matrixSizes: [100, 500, 1000],
|
||||
distances: [1000, 5000, 10900],
|
||||
iterations: 3
|
||||
});
|
||||
|
||||
spinner3.succeed('Validation completed!');
|
||||
|
||||
console.log(chalk.white('\n📈 Validation Summary:'));
|
||||
console.log(chalk.gray(` Total Tests: ${validation.summary.totalTests}`));
|
||||
console.log(chalk.green(` Validated: ${validation.summary.validated}`));
|
||||
console.log(chalk.white(` Success Rate: ${(validation.summary.averageSuccessRate * 100).toFixed(1)}%`));
|
||||
|
||||
console.log(chalk.white('\n📊 Validation Results:'));
|
||||
|
||||
// Show top results
|
||||
const topResults = validation.results
|
||||
.filter(r => r.validated)
|
||||
.sort((a, b) => parseFloat(b.temporalAdvantageMs) - parseFloat(a.temporalAdvantageMs))
|
||||
.slice(0, 5);
|
||||
|
||||
const validationTable = [
|
||||
['Matrix Size', 'Distance (km)', 'Success Rate', 'Temporal Advantage (ms)', 'Status']
|
||||
];
|
||||
|
||||
for (const r of topResults) {
|
||||
validationTable.push([
|
||||
r.matrixSize,
|
||||
r.distanceKm,
|
||||
`${(r.successRate * 100).toFixed(0)}%`,
|
||||
r.temporalAdvantageMs,
|
||||
r.validated ? chalk.green('✅ VALID') : chalk.red('❌ INVALID')
|
||||
]);
|
||||
}
|
||||
|
||||
console.log(table(validationTable));
|
||||
|
||||
console.log(chalk.cyan(`\n🎯 Conclusion: ${validation.conclusion.status}`));
|
||||
console.log(chalk.gray(` Confidence: ${validation.conclusion.confidence}`));
|
||||
console.log(chalk.white(` ${validation.conclusion.message}`));
|
||||
|
||||
} catch (error) {
|
||||
spinner3.fail('Demo 2 failed: ' + error.message);
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// DEMO 3: Performance Measurement
|
||||
// ============================================================================
|
||||
console.log(chalk.yellow('\n📏 Demo 3: Measuring System Performance\n'));
|
||||
|
||||
const spinner4 = ora('Measuring performance across configurations...').start();
|
||||
|
||||
try {
|
||||
const performance = await system.measurePerformance({
|
||||
agentCounts: [100, 500, 1000],
|
||||
matrixSizes: [100, 500],
|
||||
topologies: ['mesh', 'hierarchical']
|
||||
});
|
||||
|
||||
spinner4.succeed('Performance measurement completed!');
|
||||
|
||||
console.log(chalk.white('\n🏆 Performance Analysis:'));
|
||||
|
||||
// Best configurations
|
||||
console.log(chalk.white('\n By Agent Count:'));
|
||||
for (const [count, stats] of Object.entries(performance.analysis.byAgentCount)) {
|
||||
console.log(chalk.gray(` ${count} agents: ${stats.avgTimeMs}ms avg`));
|
||||
}
|
||||
|
||||
console.log(chalk.white('\n By Topology:'));
|
||||
for (const [topology, stats] of Object.entries(performance.analysis.byTopology)) {
|
||||
console.log(chalk.gray(` ${topology}: efficiency ${stats.avgEfficiency}`));
|
||||
}
|
||||
|
||||
console.log(chalk.white('\n💡 Recommendations:'));
|
||||
for (const rec of performance.recommendations) {
|
||||
const icon = rec.impact === 'HIGH' ? '🔴' : rec.impact === 'MEDIUM' ? '🟡' : '🟢';
|
||||
console.log(` ${icon} ${rec.category}: ${rec.recommendation}`);
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
spinner4.fail('Demo 3 failed: ' + error.message);
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// DEMO 4: Integrated System
|
||||
// ============================================================================
|
||||
console.log(chalk.yellow('\n🚀 Demo 4: Integrated Temporal Solving System\n'));
|
||||
|
||||
const spinner5 = ora('Creating integrated solving system...').start();
|
||||
|
||||
try {
|
||||
const integratedSystem = await system.createIntegratedSystem({
|
||||
name: 'GlobalTemporalSolver',
|
||||
targetDistance: 20000, // Half Earth circumference
|
||||
maxMatrixSize: 5000,
|
||||
agentBudget: 3000
|
||||
});
|
||||
|
||||
spinner5.succeed('Integrated system created!');
|
||||
|
||||
console.log(chalk.white('\n🌍 Integrated System Configuration:'));
|
||||
console.log(chalk.gray(` Name: ${integratedSystem.name}`));
|
||||
console.log(chalk.gray(` Main Solver Agents: ${integratedSystem.config.mainAgents}`));
|
||||
console.log(chalk.gray(` Verifier Agents: ${integratedSystem.config.verifierAgents}`));
|
||||
console.log(chalk.gray(` Target Matrix Size: ${integratedSystem.config.targetMatrixSize}`));
|
||||
console.log(chalk.gray(` Expected Speedup: ${integratedSystem.config.estimatedSpeedup.toFixed(2)}x`));
|
||||
|
||||
// Test the integrated system
|
||||
const testMatrix = system.generateDiagonallyDominantMatrix(500);
|
||||
const testVector = Array(500).fill(0).map(() => Math.random());
|
||||
|
||||
const spinner6 = ora('Testing integrated system...').start();
|
||||
|
||||
const integratedResult = await integratedSystem.solve(testMatrix, testVector);
|
||||
|
||||
spinner6.succeed('Integrated system test completed!');
|
||||
|
||||
console.log(chalk.white('\n✨ Integrated System Results:'));
|
||||
const integratedData = [
|
||||
['Total Time', `${integratedResult.timing.totalTimeMs} ms`],
|
||||
['Light Travel Time', `${integratedResult.timing.lightTravelTimeMs} ms`],
|
||||
['Temporal Advantage', chalk.green(`${integratedResult.timing.temporalAdvantageMs} ms`)],
|
||||
['Solved Before Arrival', integratedResult.timing.solvedBeforeArrival ? chalk.green('✅ YES') : chalk.red('❌ NO')],
|
||||
['Quantum Enhancement', `State ${integratedResult.phases.quantum.hint}`],
|
||||
['Verification Time', `${integratedResult.phases.verification.timeMs} ms`]
|
||||
];
|
||||
|
||||
console.log(table(integratedData));
|
||||
|
||||
// Monitor system
|
||||
const status = await integratedSystem.monitor();
|
||||
console.log(chalk.white('\n📡 System Status:'));
|
||||
console.log(chalk.gray(` Health: ${chalk.green(status.health)}`));
|
||||
console.log(chalk.gray(` Total Measurements: ${status.measurements.total}`));
|
||||
|
||||
// Optimize system
|
||||
if (status.measurements.total >= 10) {
|
||||
const optimization = await integratedSystem.optimize();
|
||||
console.log(chalk.white('\n🔧 Optimization Results:'));
|
||||
console.log(chalk.gray(` Status: ${optimization.status}`));
|
||||
if (optimization.optimizations) {
|
||||
for (const opt of optimization.optimizations) {
|
||||
console.log(chalk.gray(` • ${opt.action}`));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
spinner5.fail('Demo 4 failed: ' + error.message);
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// SUMMARY
|
||||
// ============================================================================
|
||||
console.log(chalk.cyan.bold('\n╔══════════════════════════════════════════════════════════╗'));
|
||||
console.log(chalk.cyan.bold('║ DEMONSTRATION COMPLETE ║'));
|
||||
console.log(chalk.cyan.bold('╚══════════════════════════════════════════════════════════╝\n'));
|
||||
|
||||
console.log(chalk.white('🎯 Key Achievements:'));
|
||||
console.log(chalk.gray(' • Demonstrated temporal advantage for matrix solving'));
|
||||
console.log(chalk.gray(' • Validated sublinear scaling across configurations'));
|
||||
console.log(chalk.gray(' • Measured performance with different agent topologies'));
|
||||
console.log(chalk.gray(' • Created integrated system with quantum enhancement'));
|
||||
|
||||
console.log(chalk.white('\n💡 Applications:'));
|
||||
console.log(chalk.gray(' • High-frequency trading with geographic advantage'));
|
||||
console.log(chalk.gray(' • Satellite communication optimization'));
|
||||
console.log(chalk.gray(' • Distributed computing across data centers'));
|
||||
console.log(chalk.gray(' • Real-time prediction systems'));
|
||||
|
||||
console.log(chalk.green('\n✅ System ready for temporal-advantage computing!\n'));
|
||||
}
|
||||
|
||||
// Run demo
|
||||
if (require.main === module) {
|
||||
main().catch(console.error);
|
||||
}
|
||||
|
||||
module.exports = { main };
|
||||
Reference in New Issue
Block a user