@stevenvo780/st-lang 2.7.1 → 2.8.0

package/dist/profiles/classical/sat-preprocess.js

@@ -0,0 +1,372 @@
+"use strict";
+// ============================================================
+// SAT Preprocessing — Simplification before solving
+// Implements: Subsumption Elimination, Self-Subsuming Resolution,
+// Bounded Variable Elimination, Failed Literal Probing
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preprocess = preprocess;
+/**
+ * Check if clause A subsumes clause B (A ⊂ B as sets).
+ * If A subsumes B, B is redundant and can be removed.
+ */
+function subsumes(a, b) {
+    if (a.length >= b.length)
+        return false;
+    let ai = 0;
+    for (let bi = 0; bi < b.length && ai < a.length; bi++) {
+        if (a[ai] === b[bi])
+            ai++;
+    }
+    return ai === a.length;
+}
+/**
+ * Subsumption Elimination:
+ * If clause A ⊂ clause B, remove B (it's redundant).
+ */
+function subsumptionElimination(clauses) {
+    // Sort clauses by length for efficient checking
+    const sorted = clauses.slice().sort((a, b) => a.length - b.length);
+    const removed = new Uint8Array(sorted.length);
+    for (let i = 0; i < sorted.length; i++) {
+        if (removed[i])
+            continue;
+        for (let j = i + 1; j < sorted.length; j++) {
+            if (removed[j])
+                continue;
+            if (subsumes(sorted[i], sorted[j])) {
+                removed[j] = 1;
+            }
+        }
+    }
+    const result = [];
+    for (let i = 0; i < sorted.length; i++) {
+        if (!removed[i])
+            result.push(sorted[i]);
+    }
+    return result;
+}
+/**
+ * Remove duplicate literals within each clause and sort them.
+ * Also removes tautological clauses (containing both x and -x).
+ */
+function normalizeClauses(clauses) {
+    const result = [];
+    for (const clause of clauses) {
+        const sorted = Array.from(clause).sort((a, b) => Math.abs(a) - Math.abs(b) || a - b);
+        // Remove duplicates and check for tautology
+        const deduped = [];
+        let tautology = false;
+        for (let i = 0; i < sorted.length; i++) {
+            if (i > 0 && sorted[i] === sorted[i - 1])
+                continue;
+            // Check for complementary literals
+            if (i > 0 && sorted[i] === -sorted[i - 1]) {
+                tautology = true;
+                break;
+            }
+            deduped.push(sorted[i]);
+        }
+        if (!tautology) {
+            result.push(new Int32Array(deduped));
+        }
+    }
+    return result;
+}
+/**
+ * Remove duplicate clauses using signature hashing.
+ */
+function removeDuplicateClauses(clauses) {
+    const seen = new Set();
+    const result = [];
+    for (const c of clauses) {
+        const key = c.join(',');
+        if (!seen.has(key)) {
+            seen.add(key);
+            result.push(c);
+        }
+    }
+    return result;
+}
+/**
+ * Self-Subsuming Resolution:
+ * If resolving A with B produces a clause that subsumes A, replace A with the resolvent.
+ * Example: {P, Q, R} resolved with {¬P, Q} → {Q, R} which subsumes {P, Q, R}
+ */
+function selfSubsumingResolution(clauses) {
+    const result = clauses.slice();
+    let changed = true;
+    let iterations = 0;
+    const maxIterations = 3; // Limit passes to prevent excessive computation
+    while (changed && iterations < maxIterations) {
+        changed = false;
+        iterations++;
+        for (let i = 0; i < result.length; i++) {
+            const ci = result[i];
+            if (ci.length === 0)
+                continue;
+            for (let j = 0; j < result.length; j++) {
+                if (i === j)
+                    continue;
+                const cj = result[j];
+                if (cj.length === 0 || cj.length > ci.length)
+                    continue;
+                // Try to resolve cj against ci on some literal
+                for (let li = 0; li < ci.length; li++) {
+                    const lit = ci[li];
+                    // Check if cj contains -lit and all other literals of cj are in ci
+                    let hasNegLit = false;
+                    let allOthersInCi = true;
+                    for (let lj = 0; lj < cj.length; lj++) {
+                        if (cj[lj] === -lit) {
+                            hasNegLit = true;
+                        }
+                        else {
+                            // Check if this literal is also in ci
+                            let found = false;
+                            for (let lk = 0; lk < ci.length; lk++) {
+                                if (ci[lk] === cj[lj]) {
+                                    found = true;
+                                    break;
+                                }
+                            }
+                            if (!found) {
+                                allOthersInCi = false;
+                                break;
+                            }
+                        }
+                    }
+                    if (hasNegLit && allOthersInCi) {
+                        // Self-subsumption: remove lit from ci
+                        const newClause = [];
+                        for (let lk = 0; lk < ci.length; lk++) {
+                            if (ci[lk] !== lit)
+                                newClause.push(ci[lk]);
+                        }
+                        result[i] = new Int32Array(newClause);
+                        changed = true;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Bounded Variable Elimination (BVE):
+ * If a variable appears few times, resolve all its positive clauses against
+ * negative clauses and check if the result is smaller.
+ */
+function boundedVariableElimination(clauses, numVars) {
+    const eliminated = new Set();
+    let current = clauses.slice();
+    const MAX_GROWTH = 0; // Only eliminate if it doesn't increase clause count
+    for (let v = 1; v <= numVars; v++) {
+        const posClauses = [];
+        const negClauses = [];
+        for (let ci = 0; ci < current.length; ci++) {
+            for (let li = 0; li < current[ci].length; li++) {
+                if (current[ci][li] === v) {
+                    posClauses.push(ci);
+                    break;
+                }
+                if (current[ci][li] === -v) {
+                    negClauses.push(ci);
+                    break;
+                }
+            }
+        }
+        // Skip if too many resolvents would be created
+        if (posClauses.length * negClauses.length >
+            posClauses.length + negClauses.length + MAX_GROWTH) {
+            continue;
+        }
+        // Generate all resolvents
+        const resolvents = [];
+        const tooLarge = false;
+        for (const pi of posClauses) {
+            for (const ni of negClauses) {
+                const resolvent = resolve(current[pi], current[ni], v);
+                if (resolvent === null)
+                    continue; // tautology
+                resolvents.push(resolvent);
+            }
+        }
+        if (tooLarge)
+            continue;
+        // Only eliminate if result has fewer or equal clauses
+        if (resolvents.length <= posClauses.length + negClauses.length) {
+            // Remove old clauses and add resolvents
+            const toRemove = new Set([...posClauses, ...negClauses]);
+            const newClauses = [];
+            for (let ci = 0; ci < current.length; ci++) {
+                if (!toRemove.has(ci))
+                    newClauses.push(current[ci]);
+            }
+            newClauses.push(...resolvents);
+            current = newClauses;
+            eliminated.add(v);
+        }
+    }
+    return { clauses: current, eliminated };
+}
+/**
+ * Resolve two clauses on variable v.
+ * Returns null if the resolvent is a tautology.
+ */
+function resolve(a, b, v) {
+    const lits = new Set();
+    for (let i = 0; i < a.length; i++) {
+        const l = a[i];
+        if (l !== v && l !== -v)
+            lits.add(l);
+    }
+    for (let i = 0; i < b.length; i++) {
+        const l = b[i];
+        if (l !== v && l !== -v) {
+            if (lits.has(-l))
+                return null; // tautology
+            lits.add(l);
+        }
+    }
+    return new Int32Array(Array.from(lits).sort((a, b) => a - b));
+}
+/**
+ * Failed Literal Probing:
+ * For each unassigned variable, assume it's true and propagate.
+ * If conflict → the variable must be false (and vice versa).
+ */
+function failedLiteralProbing(clauses, numVars) {
+    const forced = [];
+    for (let v = 1; v <= numVars; v++) {
+        // Try v = true
+        const trueResult = probeAssignment(clauses, numVars, v);
+        // Try v = false
+        const falseResult = probeAssignment(clauses, numVars, -v);
+        if (trueResult === 'conflict' && falseResult === 'conflict') {
+            // Both conflict → UNSAT, but we handle this later
+            return { forcedLiterals: forced, clauses };
+        }
+        if (trueResult === 'conflict') {
+            forced.push(-v);
+        }
+        else if (falseResult === 'conflict') {
+            forced.push(v);
+        }
+    }
+    // Apply forced literals
+    let current = clauses;
+    for (const lit of forced) {
+        current = applyLiteral(current, lit);
+    }
+    return { forcedLiterals: forced, clauses: current };
+}
+/**
+ * Probe: assign a literal and run unit propagation.
+ * Returns 'conflict' if a conflict is found, 'ok' otherwise.
+ */
+function probeAssignment(clauses, numVars, lit) {
+    let current = applyLiteral(clauses, lit);
+    // Run simple unit propagation
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const c of current) {
+            if (c.length === 0)
+                return 'conflict';
+            if (c.length === 1) {
+                current = applyLiteral(current, c[0]);
+                changed = true;
+                break;
+            }
+        }
+    }
+    return 'ok';
+}
+/**
+ * Apply a literal assignment to a clause set.
+ * Removes satisfied clauses and shrinks clauses containing -lit.
+ */
+function applyLiteral(clauses, lit) {
+    const result = [];
+    for (const c of clauses) {
+        let satisfied = false;
+        const remaining = [];
+        for (let i = 0; i < c.length; i++) {
+            if (c[i] === lit) {
+                satisfied = true;
+                break;
+            }
+            if (c[i] !== -lit)
+                remaining.push(c[i]);
+        }
+        if (!satisfied) {
+            result.push(new Int32Array(remaining));
+        }
+    }
+    return result;
+}
+/**
+ * Main preprocessing pipeline.
+ * Applies simplifications in order of effectiveness.
+ */
+function preprocess(clauses, numVars) {
+    // Step 0: normalize and deduplicate
+    let current = normalizeClauses(clauses);
+    current = removeDuplicateClauses(current);
+    // Check trivial cases
+    for (const c of current) {
+        if (c.length === 0) {
+            return { clauses: current, forcedLiterals: [], eliminated: false, trivialUnsat: true };
+        }
+    }
+    const initialCount = current.length;
+    const allForced = [];
+    // Step 1: extract unit clauses
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (let i = 0; i < current.length; i++) {
+            if (current[i].length === 1) {
+                const lit = current[i][0];
+                allForced.push(lit);
+                current = applyLiteral(current, lit);
+                changed = true;
+                break;
+            }
+        }
+    }
+    // Step 2: subsumption elimination
+    current = subsumptionElimination(current);
+    // Step 3: self-subsuming resolution
+    current = selfSubsumingResolution(current);
+    // Step 4: Bounded Variable Elimination (only for small formulas to avoid blowup)
+    if (numVars <= 500) {
+        const bve = boundedVariableElimination(current, numVars);
+        current = bve.clauses;
+    }
+    // Step 5: Failed Literal Probing (only for moderate sizes)
+    if (numVars <= 200) {
+        const flp = failedLiteralProbing(current, numVars);
+        allForced.push(...flp.forcedLiterals);
+        current = flp.clauses;
+    }
+    // Final normalization
+    current = normalizeClauses(current);
+    current = removeDuplicateClauses(current);
+    current = subsumptionElimination(current);
+    // Check for empty clause after all preprocessing
+    for (const c of current) {
+        if (c.length === 0) {
+            return { clauses: current, forcedLiterals: allForced, eliminated: true, trivialUnsat: true };
+        }
+    }
+    return {
+        clauses: current,
+        forcedLiterals: allForced,
+        eliminated: current.length < initialCount,
+        trivialUnsat: false,
+    };
+}
+//# sourceMappingURL=sat-preprocess.js.map

package/dist/profiles/classical/sat-preprocess.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sat-preprocess.js","sourceRoot":"","sources":["../../../src/profiles/classical/sat-preprocess.ts"],"names":[],"mappings":"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"}

package/dist/profiles/classical/undecidability-detector.d.ts

@@ -0,0 +1,13 @@
+import { Formula } from '../../types';
+export interface UndecidabilityWarning {
+    pattern: string;
+    description: string;
+    severity: 'info' | 'warning' | 'critical';
+    suggestion: string;
+}
+/**
+ * Analyze a first-order formula for known undecidable or computationally
+ * intractable patterns. Returns warnings if any are detected.
+ */
+export declare function detectUndecidable(formula: Formula): UndecidabilityWarning[];
+//# sourceMappingURL=undecidability-detector.d.ts.map

package/dist/profiles/classical/undecidability-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"undecidability-detector.d.ts","sourceRoot":"","sources":["../../../src/profiles/classical/undecidability-detector.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtC,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,CAAC;IAC1C,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,qBAAqB,EAAE,CAqF3E"}

package/dist/profiles/classical/undecidability-detector.js

@@ -0,0 +1,277 @@
+"use strict";
+// ============================================================
+// FOL Undecidability Detector
+// Detects patterns known to be undecidable in first-order logic,
+// provides meaningful warnings to users.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectUndecidable = detectUndecidable;
+/**
+ * Analyze a first-order formula for known undecidable or computationally
+ * intractable patterns. Returns warnings if any are detected.
+ */
+function detectUndecidable(formula) {
+    const warnings = [];
+    // 1. Quantifier alternation depth
+    const altDepth = quantifierAlternationDepth(formula);
+    if (altDepth >= 3) {
+        warnings.push({
+            pattern: 'quantifier_alternation',
+            description: `Alternación de cuantificadores de profundidad ${altDepth} (∀∃∀...) detectada. ` +
+                `La satisfacibilidad de fórmulas con alternación profunda es computacionalmente extrema.`,
+            severity: altDepth >= 4 ? 'critical' : 'warning',
+            suggestion: 'Considere reducir la alternación de cuantificadores o usar fragmentos decidibles (∃*, ∀∃*, Bernays-Schönfinkel).',
+        });
+    }
+    // 2. Nested quantifiers depth
+    const nestDepth = quantifierNestingDepth(formula);
+    if (nestDepth >= 5) {
+        warnings.push({
+            pattern: 'deep_quantifier_nesting',
+            description: `Anidamiento de cuantificadores de profundidad ${nestDepth}. ` +
+                `El tableau puede requerir tiempo exponencial.`,
+            severity: nestDepth >= 8 ? 'critical' : 'warning',
+            suggestion: 'Simplifique la fórmula reduciendo niveles de anidamiento cuantificado.',
+        });
+    }
+    // 3. Self-reference patterns (Gödel-like)
+    if (hasSelfReference(formula)) {
+        warnings.push({
+            pattern: 'goedel_self_reference',
+            description: `Posible auto-referencia detectada (patrón similar a la sentencia de Gödel). ` +
+                `No existe algoritmo que pueda decidir todas las fórmulas auto-referenciales (Gödel, 1931).`,
+            severity: 'critical',
+            suggestion: 'Las fórmulas auto-referenciales son inherentemente indecidibles en aritmética formal.',
+        });
+    }
+    // 4. Function symbols with deep nesting (potential infinity)
+    const fnDepth = functionNestingDepth(formula);
+    if (fnDepth >= 4) {
+        warnings.push({
+            pattern: 'deep_function_nesting',
+            description: `Funciones anidadas de profundidad ${fnDepth} con cuantificadores. ` +
+                `Esto puede generar infinitos términos durante la instanciación.`,
+            severity: fnDepth >= 6 ? 'critical' : 'warning',
+            suggestion: 'Limite la profundidad de términos funcionales o use skolemización temprana.',
+        });
+    }
+    // 5. Monadic vs polyadic predicates
+    const predicateArities = collectPredicateArities(formula);
+    const hasPolyadic = Array.from(predicateArities.values()).some((a) => a >= 3);
+    if (hasPolyadic && altDepth >= 2) {
+        warnings.push({
+            pattern: 'polyadic_with_alternation',
+            description: `Predicados con aridad ≥3 combinados con alternación de cuantificadores. ` +
+                `Este fragmento es generalmente indecidible (Church, 1936).`,
+            severity: 'warning',
+            suggestion: 'El fragmento monádico (aridad 1) de FOL es decidible. Considere reducir la aridad de predicados.',
+        });
+    }
+    // 6. Detect potential infinite domain requirements
+    if (requiresInfiniteDomain(formula)) {
+        warnings.push({
+            pattern: 'infinite_domain',
+            description: `La fórmula parece requerir un dominio infinito para ser satisfacible. ` +
+                `Solo la búsqueda en dominios finitos es decidible.`,
+            severity: 'info',
+            suggestion: 'ST buscará modelos en dominios finitos crecientes. Si es válida solo en dominios infinitos, el tableau puede no terminar.',
+        });
+    }
+    return warnings;
+}
+/**
+ * Count the maximum quantifier alternation depth.
+ * ∀∃ = 1, ∀∃∀ = 2, ∀∃∀∃ = 3, etc.
+ */
+function quantifierAlternationDepth(f) {
+    let maxDepth = 0;
+    function walk(node, lastQ, depth) {
+        if (node.kind === 'forall' || node.kind === 'exists') {
+            const currentQ = node.kind;
+            const newDepth = lastQ !== '' && lastQ !== currentQ ? depth + 1 : depth;
+            maxDepth = Math.max(maxDepth, newDepth);
+            if (node.args) {
+                for (const arg of node.args) {
+                    walk(arg, currentQ, newDepth);
+                }
+            }
+            // Also check body (second arg for forall/exists)
+            if (node.args && node.args.length >= 2) {
+                walk(node.args[1], currentQ, newDepth);
+            }
+        }
+        else {
+            if (node.args) {
+                for (const arg of node.args) {
+                    walk(arg, lastQ, depth);
+                }
+            }
+        }
+    }
+    walk(f, '', 0);
+    return maxDepth;
+}
+/**
+ * Count the maximum quantifier nesting depth.
+ */
+function quantifierNestingDepth(f) {
+    let maxDepth = 0;
+    function walk(node, depth) {
+        if (node.kind === 'forall' || node.kind === 'exists') {
+            const newDepth = depth + 1;
+            maxDepth = Math.max(maxDepth, newDepth);
+            if (node.args) {
+                for (const arg of node.args) {
+                    walk(arg, newDepth);
+                }
+            }
+        }
+        else {
+            if (node.args) {
+                for (const arg of node.args) {
+                    walk(arg, depth);
+                }
+            }
+        }
+    }
+    walk(f, 0);
+    return maxDepth;
+}
+/**
+ * Detect self-referential patterns in formulas.
+ * Looks for predicates that reference their own derivability
+ * or formulas that encode their own truth conditions.
+ */
+function hasSelfReference(f) {
+    // Collect all predicate names
+    const predicates = new Set();
+    const atoms = new Set();
+    function collectNames(node) {
+        if (node.kind === 'predicate' && node.name) {
+            predicates.add(node.name);
+        }
+        if (node.kind === 'atom' && node.name) {
+            atoms.add(node.name);
+        }
+        if (node.args) {
+            for (const arg of node.args) {
+                collectNames(arg);
+            }
+        }
+    }
+    collectNames(f);
+    // Check for names that suggest self-reference
+    const selfRefPatterns = [
+        /^(provable|derivable|demostrable)/i,
+        /^(truth|verdad|true_of)/i,
+        /^(goedel|godel|diagonal)/i,
+        /^(halts?|termina)/i,
+        /^(self|auto|reflexi)/i,
+    ];
+    for (const name of [...predicates, ...atoms]) {
+        for (const pattern of selfRefPatterns) {
+            if (pattern.test(name))
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Calculate maximum function symbol nesting depth.
+ */
+function functionNestingDepth(f) {
+    let maxDepth = 0;
+    function walk(node, depth) {
+        if (node.kind === 'fn_call') {
+            const newDepth = depth + 1;
+            maxDepth = Math.max(maxDepth, newDepth);
+            if (node.args) {
+                for (const arg of node.args) {
+                    walk(arg, newDepth);
+                }
+            }
+        }
+        else if (node.kind === 'predicate') {
+            // Reset depth for predicate arguments
+            if (node.args) {
+                for (const arg of node.args) {
+                    walk(arg, 0);
+                }
+            }
+        }
+        else {
+            if (node.args) {
+                for (const arg of node.args) {
+                    walk(arg, depth);
+                }
+            }
+        }
+    }
+    walk(f, 0);
+    return maxDepth;
+}
+/**
+ * Collect predicate arities.
+ */
+function collectPredicateArities(f) {
+    const arities = new Map();
+    function walk(node) {
+        if (node.kind === 'predicate' && node.name && node.args) {
+            const arity = node.args.length;
+            const existing = arities.get(node.name);
+            if (existing === undefined || arity > existing) {
+                arities.set(node.name, arity);
+            }
+        }
+        if (node.args) {
+            for (const arg of node.args) {
+                walk(arg);
+            }
+        }
+    }
+    walk(f);
+    return arities;
+}
+/**
+ * Detect if a formula likely requires an infinite domain.
+ * Patterns: ∀x∃y(y ≠ x), successor axioms, induction schemas.
+ */
+function requiresInfiniteDomain(f) {
+    // Look for ∀x∃y patterns where y depends on x
+    let hasForallExists = false;
+    let hasDisequalityPattern = false;
+    function walk(node, inForall) {
+        if (node.kind === 'forall') {
+            if (node.args) {
+                for (const arg of node.args) {
+                    walk(arg, true);
+                }
+            }
+        }
+        else if (node.kind === 'exists' && inForall) {
+            hasForallExists = true;
+            if (node.args) {
+                for (const arg of node.args) {
+                    walk(arg, inForall);
+                }
+            }
+        }
+        else {
+            // Check for inequality-like patterns
+            if (node.kind === 'not') {
+                if (node.args?.[0]?.kind === 'atom' || node.args?.[0]?.kind === 'predicate') {
+                    if (hasForallExists)
+                        hasDisequalityPattern = true;
+                }
+            }
+            if (node.args) {
+                for (const arg of node.args) {
+                    walk(arg, inForall);
+                }
+            }
+        }
+    }
+    walk(f, false);
+    return hasForallExists && hasDisequalityPattern;
+}
+//# sourceMappingURL=undecidability-detector.js.map