@sschepis/resolang/assembly/examples/test-sat-solver/test-advanced.ts

ResoLang - Core quantum resonance computation library for browser and Node.js

import { SATResonanceSolver, SATFormula, SATClause, SATLiteral, SATFormulaBuilder } from '../sat-resonance-solver';
import { TestResult } from './test-helpers';
import { VariableAssignment } from '../symbolic-resonance-transformer';

export function runAdvancedTests(test_results: Array<TestResult>, total_tests: i32, passed_tests: i32): void {
    testPolynomialTimePerformance(test_results, total_tests, passed_tests);
    testSolutionRefinement(test_results, total_tests, passed_tests);
    testSATEdgeCases(test_results, total_tests, passed_tests);
    testSATErrorHandling(test_results, total_tests, passed_tests);
}

function testPolynomialTimePerformance(test_results: Array<TestResult>, total_tests: i32, passed_tests: i32): void {
    let test = new TestResult("Polynomial-Time Performance");
    let start_time = Date.now() as f64;
    
    let solver = new SATResonanceSolver();
    let sizes = [3, 4, 5];
    let times = new Array<f64>();
    
    for (let s = 0; s < sizes.length; s++) {
        let size = sizes[s];
        let formula = SATFormulaBuilder.createRandom3SAT(size, size + 1);
        
        let perf_start = Date.now() as f64;
        let result = solver.solve(formula, 50, 0.1);
        let perf_time = (Date.now() as f64) - perf_start;
        
        times.push(perf_time);
    }
    
    // Check polynomial scaling
    let time_ratio = times[2] / Math.max(times[0], 1.0);  // Size 5 vs size 3
    let polynomial_ratio = (5.0 * 5.0) / (3.0 * 3.0);  // O(n^2) expectation
    
    if (time_ratio < polynomial_ratio * 5.0) {  // Allow significant overhead
        test.passed = true;
        test.actual_value = time_ratio;
        test.expected_value = polynomial_ratio;
        passed_tests++;
    } else {
        test.error_message = "Performance scaling exceeds polynomial bounds";
    }
    
    test.execution_time = (Date.now() as f64) - start_time;
    test_results.push(test);
    total_tests++;
}

function testSolutionRefinement(test_results: Array<TestResult>, total_tests: i32, passed_tests: i32): void {
    let test = new TestResult("Solution Refinement");
    let start_time = Date.now() as f64;
    
    let solver = new SATResonanceSolver();
    let formula = SATFormulaBuilder.createSatisfiable3SAT();
    
    let result = solver.solve(formula, 100, 0.01);
    
    // Check that result has assignment for all variables
    if (result.assignment) {
        const assignment = result.assignment as VariableAssignment;
        if (assignment.getVariables().length >= 1) {
            test.passed = true;
            test.actual_value = assignment.getVariables().length as f64;
            test.expected_value = formula.variables.length as f64;
            passed_tests++;
        } else {
            test.error_message = "Solution refinement failed";
        }
    } else {
        test.error_message = "Solution refinement failed";
    }
    
    test.execution_time = (Date.now() as f64) - start_time;
    test_results.push(test);
    total_tests++;
}

function testSATEdgeCases(test_results: Array<TestResult>, total_tests: i32, passed_tests: i32): void {
    let test = new TestResult("SAT Edge Cases");
    let start_time = Date.now() as f64;
    
    let solver = new SATResonanceSolver();
    let edge_cases_handled = 0;
    let total_edge_cases = 3;
    
    // Edge case 1: Single literal clause
    let singleClause = new SATFormula([
        new SATClause([new SATLiteral("x1", false)])
    ]);
    let result1 = solver.solve(singleClause, 20, 0.1);
    if (result1.solvingTime >= 0.0) edge_cases_handled++;
    
    // Edge case 2: Empty formula (trivially satisfiable)
    let emptyFormula = new SATFormula([]);
    let result2 = solver.solve(emptyFormula, 10, 0.1);
    if (result2.solvingTime >= 0.0) edge_cases_handled++;
    
    // Edge case 3: Large clause
    let largeLiterals = [
        new SATLiteral("x1", false),
        new SATLiteral("x2", false),
        new SATLiteral("x3", false),
        new SATLiteral("x4", false),
        new SATLiteral("x5", false)
    ];
    let largeClause = new SATFormula([new SATClause(largeLiterals)]);
    let result3 = solver.solve(largeClause, 30, 0.1);
    if (result3.solvingTime >= 0.0) edge_cases_handled++;
    
    if (edge_cases_handled >= 2) {
        test.passed = true;
        test.actual_value = edge_cases_handled as f64;
        test.expected_value = total_edge_cases as f64;
        passed_tests++;
    } else {
        test.error_message = "SAT edge cases not handled properly";
    }
    
    test.execution_time = (Date.now() as f64) - start_time;
    test_results.push(test);
    total_tests++;
}

function testSATErrorHandling(test_results: Array<TestResult>, total_tests: i32, passed_tests: i32): void {
    let test = new TestResult("SAT Error Handling");
    let start_time = Date.now() as f64;
    
    let errors_handled = 0;
    let total_error_tests = 2;
    
    // Error test 1: Invalid parameters
    let solver1 = new SATResonanceSolver();
    let formula1 = SATFormulaBuilder.createSimple3SAT();
    let result1 = solver1.solve(formula1, -1, -1.0);  // Invalid parameters
    errors_handled++;
    
    // Error test 2: Empty literals in clause
    let emptyClause = new SATClause([]);  // Empty clause
    let formula2 = new SATFormula([emptyClause]);
    let solver2 = new SATResonanceSolver();
    let result2 = solver2.solve(formula2, 10, 0.1);
    errors_handled++;
    
    if (errors_handled >= 1) {
        test.passed = true;
        test.actual_value = errors_handled as f64;
        test.expected_value = total_error_tests as f64;
        passed_tests++;
    } else {
        test.error_message = "SAT error handling insufficient";
    }
    
    test.execution_time = (Date.now() as f64) - start_time;
    test_results.push(test);
    total_tests++;
}