@stevenvo780/st-lang 2.6.1 → 2.7.0

package/dist/profiles/classical/propositional.js

@@ -5,6 +5,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClassicalPropositional = void 0;
 exports.collectAtoms = collectAtoms;
+exports.evaluateClassical = evaluateClassical;
+exports.generateValuationsLazy = generateValuationsLazy;
 exports.formulaToString = formulaToString;
 exports.toNNF = toNNF;
 exports.toCNF = toCNF;
@@ -32,39 +34,39 @@ function computeCollectAtoms(f) {
     walk(f);
     return atoms;
 }
-function evaluate(f, v) {
+function evaluateClassical(f, v) {
     switch (f.kind) {
         case 'atom':
             return f.name ? (v[f.name] ?? false) : false;
         case 'not':
-            return f.args && f.args[0] ? !evaluate(f.args[0], v) : false;
+            return f.args && f.args[0] ? !evaluateClassical(f.args[0], v) : false;
         case 'and':
             return f.args && f.args[0] && f.args[1]
-                ? evaluate(f.args[0], v) && evaluate(f.args[1], v)
+                ? evaluateClassical(f.args[0], v) && evaluateClassical(f.args[1], v)
                 : false;
         case 'or':
             return f.args && f.args[0] && f.args[1]
-                ? evaluate(f.args[0], v) || evaluate(f.args[1], v)
+                ? evaluateClassical(f.args[0], v) || evaluateClassical(f.args[1], v)
                 : false;
         case 'implies':
             return f.args && f.args[0] && f.args[1]
-                ? !evaluate(f.args[0], v) || evaluate(f.args[1], v)
+                ? !evaluateClassical(f.args[0], v) || evaluateClassical(f.args[1], v)
                 : false;
         case 'biconditional':
             return f.args && f.args[0] && f.args[1]
-                ? evaluate(f.args[0], v) === evaluate(f.args[1], v)
+                ? evaluateClassical(f.args[0], v) === evaluateClassical(f.args[1], v)
                 : false;
         case 'nand':
             return f.args && f.args[0] && f.args[1]
-                ? !(evaluate(f.args[0], v) && evaluate(f.args[1], v))
+                ? !(evaluateClassical(f.args[0], v) && evaluateClassical(f.args[1], v))
                 : false;
         case 'nor':
             return f.args && f.args[0] && f.args[1]
-                ? !(evaluate(f.args[0], v) || evaluate(f.args[1], v))
+                ? !(evaluateClassical(f.args[0], v) || evaluateClassical(f.args[1], v))
                 : false;
         case 'xor':
             return f.args && f.args[0] && f.args[1]
-                ? evaluate(f.args[0], v) !== evaluate(f.args[1], v)
+                ? evaluateClassical(f.args[0], v) !== evaluateClassical(f.args[1], v)
                 : false;
         default:
             throw new Error(`Operador lógico no soportado en evaluación clásica: ${f.kind}`);
@@ -93,6 +95,184 @@ function generateValuations(atoms) {
     }
     return valuations;
 }
+/**
+ * Generador lazy de valuaciones para streaming (usado por el intérprete para truth_table masivas).
+ */
+function* generateValuationsLazy(atoms) {
+    const n = atoms.length;
+    if (n === 0) {
+        yield {};
+        return;
+    }
+    const total = 1 << n;
+    for (let i = 0; i < total; i++) {
+        const v = {};
+        for (let j = 0; j < n; j++) {
+            v[atoms[j]] = Boolean((i >> (n - 1 - j)) & 1);
+        }
+        yield v;
+    }
+}
+function bvCreate(total) {
+    return new Uint32Array((total + 31) >>> 5);
+}
+function bvOnes(total) {
+    const words = (total + 31) >>> 5;
+    const v = new Uint32Array(words);
+    v.fill(0xffffffff);
+    // Clear trailing bits in last word
+    const tail = total & 31;
+    if (tail)
+        v[words - 1] = (1 << tail) - 1;
+    return v;
+}
+function bvAnd(a, b) {
+    const r = new Uint32Array(a.length);
+    for (let i = 0; i < a.length; i++)
+        r[i] = a[i] & b[i];
+    return r;
+}
+function bvOr(a, b) {
+    const r = new Uint32Array(a.length);
+    for (let i = 0; i < a.length; i++)
+        r[i] = a[i] | b[i];
+    return r;
+}
+function bvXor(a, b) {
+    const r = new Uint32Array(a.length);
+    for (let i = 0; i < a.length; i++)
+        r[i] = a[i] ^ b[i];
+    return r;
+}
+function bvNot(a, ones) {
+    const r = new Uint32Array(a.length);
+    for (let i = 0; i < a.length; i++)
+        r[i] = ~a[i] & ones[i];
+    return r;
+}
+function bvIsZero(a) {
+    for (let i = 0; i < a.length; i++)
+        if (a[i] !== 0)
+            return false;
+    return true;
+}
+function bvEquals(a, b) {
+    for (let i = 0; i < a.length; i++)
+        if (a[i] !== b[i])
+            return false;
+    return true;
+}
+function bvPopcount(a) {
+    let count = 0;
+    for (let i = 0; i < a.length; i++) {
+        let v = a[i];
+        v = v - ((v >>> 1) & 0x55555555);
+        v = (v & 0x33333333) + ((v >>> 2) & 0x33333333);
+        count += (((v + (v >>> 4)) & 0x0f0f0f0f) * 0x01010101) >>> 24;
+    }
+    return count;
+}
+function bvTestBit(a, i) {
+    return (a[i >>> 5] & (1 << (i & 31))) !== 0;
+}
+// Find first set bit, or -1
+function bvFirstSet(a) {
+    for (let w = 0; w < a.length; w++) {
+        if (a[w] !== 0)
+            return ((w << 5) + Math.clz32(a[w] & (-a[w] | 0))) ^ 31;
+    }
+    return -1;
+}
+function evaluateBitset(formula, atoms) {
+    const n = atoms.length;
+    if (n > 26)
+        throw new Error('Demasiadas variables para evaluación bitset (>26)');
+    const total = 1 << n;
+    const allOnes = bvOnes(total);
+    const words = allOnes.length;
+    // Build atom masks: atom j is true when bit j of the row index is 1.
+    // Row index i has bit j set when (i >>> (n-1-j)) & 1.
+    // Equivalent: word w, bit b (i = w*32+b), atom j true iff ((w*32+b) >>> (n-1-j)) & 1.
+    const atomMasks = new Map();
+    for (let j = 0; j < n; j++) {
+        const shift = n - 1 - j;
+        const mask = bvCreate(total);
+        // The pattern for atom j repeats with period 2^(shift+1).
+        // Within each period, the first 2^shift bits are 0, next 2^shift are 1.
+        // For shift < 5, the pattern fits within single words and we can use word-level fill.
+        if (shift < 5) {
+            // Pattern period in bits
+            const period = 1 << (shift + 1);
+            const halfPeriod = 1 << shift;
+            // Build a 32-bit pattern
+            let pattern = 0;
+            for (let b = 0; b < 32; b++) {
+                if (b % period >= halfPeriod)
+                    pattern |= 1 << b;
+            }
+            mask.fill(pattern);
+        }
+        else {
+            // shift >= 5: consecutive words are all-0 or all-1
+            const wordPeriod = 1 << (shift - 5 + 1); // period in words
+            const halfWordPeriod = wordPeriod >>> 1;
+            for (let w = 0; w < words; w++) {
+                const posInPeriod = w % wordPeriod;
+                mask[w] = posInPeriod >= halfWordPeriod ? 0xffffffff : 0;
+            }
+        }
+        // Clear trailing bits
+        const tail = total & 31;
+        if (tail && words > 0)
+            mask[words - 1] &= (1 << tail) - 1;
+        atomMasks.set(atoms[j], mask);
+    }
+    function evalBits(f) {
+        switch (f.kind) {
+            case 'atom':
+                return atomMasks.get(f.name) ?? bvCreate(total);
+            case 'not':
+                return bvNot(evalBits(f.args[0]), allOnes);
+            case 'and':
+                return bvAnd(evalBits(f.args[0]), evalBits(f.args[1]));
+            case 'or':
+                return bvOr(evalBits(f.args[0]), evalBits(f.args[1]));
+            case 'implies':
+                return bvOr(bvNot(evalBits(f.args[0]), allOnes), evalBits(f.args[1]));
+            case 'biconditional':
+                return bvNot(bvXor(evalBits(f.args[0]), evalBits(f.args[1])), allOnes);
+            case 'xor':
+                return bvXor(evalBits(f.args[0]), evalBits(f.args[1]));
+            case 'nand':
+                return bvNot(bvAnd(evalBits(f.args[0]), evalBits(f.args[1])), allOnes);
+            case 'nor':
+                return bvNot(bvOr(evalBits(f.args[0]), evalBits(f.args[1])), allOnes);
+            default:
+                throw new Error(`Operador no soportado en evaluación bitset: ${f.kind}`);
+        }
+    }
+    return { result: evalBits(formula), atomMasks, total, allOnes };
+}
+function bitsetPopcount(a) {
+    return bvPopcount(a);
+}
+function isPurePropositional(f) {
+    switch (f.kind) {
+        case 'atom':
+            return true;
+        case 'not':
+        case 'and':
+        case 'or':
+        case 'implies':
+        case 'biconditional':
+        case 'xor':
+        case 'nand':
+        case 'nor':
+            return (f.args || []).every(isPurePropositional);
+        default:
+            return false;
+    }
+}
 /**
  * Aplana recursivamente nodos binarios del mismo kind asociativo.
  * Ej: or(or(P,Q), R) → [P, Q, R]
@@ -219,6 +399,9 @@ function computeFormulaToString(f) {
     }
 }
 function toNNF(f) {
+    return (0, memo_1.memoizeNNF)(f, computeNNF);
+}
+function computeNNF(f) {
     const simplify = (node, negated) => {
         const k = node.kind;
         const args = node.args || [];
@@ -351,7 +534,7 @@ function distributeOrOverAnd(f) {
     return f;
 }
 function toCNF(f) {
-    return distributeOrOverAnd(toNNF(f));
+    return (0, memo_1.memoizeCNF)(f, (formula) => distributeOrOverAnd(toNNF(formula)));
 }
 function distributeAndOverOr(f) {
     if (f.kind === 'and' && f.args?.[0] && f.args?.[1]) {
@@ -382,7 +565,7 @@ function distributeAndOverOr(f) {
     return f;
 }
 function toDNF(f) {
-    return distributeAndOverOr(toNNF(f));
+    return (0, memo_1.memoizeDNF)(f, (formula) => distributeAndOverOr(toNNF(formula)));
 }
 /**
  * Extracts clauses from a CNF formula for resolution analysis (#28)
@@ -943,23 +1126,47 @@ function tryDerive(goal, theory, premiseNames) {
         for (const f of allAxiomFormulas)
             collectAtoms(f).forEach((a) => atoms.add(a));
         collectAtoms(goal).forEach((a) => atoms.add(a));
-        const atomList = Array.from(atoms);
-        const valuations = generateValuations(atomList);
-        let semanticallyValid = true;
-        for (const v of valuations) {
-            const premisesTrue = allAxiomFormulas.every((f) => evaluate(f, v));
-            if (premisesTrue && !evaluate(goal, v)) {
-                semanticallyValid = false;
-                break;
+        const atomList = Array.from(atoms).sort();
+        // Fast path: bitset semantic check
+        const allPure = allAxiomFormulas.every(isPurePropositional) && isPurePropositional(goal);
+        if (allPure && atomList.length <= 26) {
+            const premiseBits = allAxiomFormulas.map((f) => evaluateBitset(f, atomList).result);
+            const goalBits = evaluateBitset(goal, atomList).result;
+            const allOnes = bvOnes(1 << atomList.length);
+            // Conjunction of all premises
+            let premisesConj = allOnes;
+            for (const pb of premiseBits)
+                premisesConj = bvAnd(premisesConj, pb);
+            // Valid if: wherever premises are true, goal is also true
+            // i.e., premisesConj & ~goalBits === 0
+            if (bvIsZero(bvAnd(premisesConj, bvNot(goalBits, allOnes)))) {
+                return {
+                    goal,
+                    steps: state.steps,
+                    status: 'complete',
+                    derivedFrom: premiseNames,
+                };
             }
         }
-        if (semanticallyValid) {
-            return {
-                goal,
-                steps: state.steps,
-                status: 'complete',
-                derivedFrom: premiseNames,
-            };
+        else {
+            // Classic fallback
+            const valuations = generateValuations(atomList);
+            let semanticallyValid = true;
+            for (const v of valuations) {
+                const premisesTrue = allAxiomFormulas.every((f) => evaluateClassical(f, v));
+                if (premisesTrue && !evaluateClassical(goal, v)) {
+                    semanticallyValid = false;
+                    break;
+                }
+            }
+            if (semanticallyValid) {
+                return {
+                    goal,
+                    steps: state.steps,
+                    status: 'complete',
+                    derivedFrom: premiseNames,
+                };
+            }
         }
     }
     return null;
@@ -1054,6 +1261,20 @@ class ClassicalPropositional {
         if (wf.length > 0) {
             return { status: 'error', diagnostics: wf, formula };
         }
+        // Fast path: bitset validity check (no row materialization)
+        const atoms = Array.from(collectAtoms(formula)).sort();
+        if (isPurePropositional(formula) && atoms.length <= 26) {
+            const { result, allOnes } = evaluateBitset(formula, atoms);
+            const isValid = bvEquals(result, allOnes);
+            return {
+                status: isValid ? 'valid' : 'invalid',
+                output: isValid
+                    ? `${formulaToString(formula)} es VALIDA (tautologia)`
+                    : `${formulaToString(formula)} NO es valida`,
+                diagnostics: [],
+                formula,
+            };
+        }
         const tt = this.truthTable(formula);
         if (tt.isTautology) {
             return {
@@ -1065,7 +1286,6 @@ class ClassicalPropositional {
             };
         }
         else {
-            // Encontrar contramodelo
             const cm = tt.rows.find((r) => !r.result);
             return {
                 status: 'invalid',
@@ -1082,6 +1302,20 @@ class ClassicalPropositional {
         if (wf.length > 0) {
             return { status: 'error', diagnostics: wf, formula };
         }
+        // Fast path: bitset satisfiability check (no row materialization)
+        const atoms = Array.from(collectAtoms(formula)).sort();
+        if (isPurePropositional(formula) && atoms.length <= 26) {
+            const { result } = evaluateBitset(formula, atoms);
+            const isSat = !bvIsZero(result);
+            return {
+                status: isSat ? 'satisfiable' : 'unsatisfiable',
+                output: isSat
+                    ? `${formulaToString(formula)} es SATISFACIBLE`
+                    : `${formulaToString(formula)} es INSATISFACIBLE (contradiccion)`,
+                diagnostics: [],
+                formula,
+            };
+        }
         const tt = this.truthTable(formula);
         if (tt.isSatisfiable) {
             const sat = tt.rows.find((r) => r.result);
@@ -1171,11 +1405,39 @@ class ClassicalPropositional {
         if (wf.length > 0) {
             return { status: 'error', diagnostics: wf, formula };
         }
-        const atoms = Array.from(collectAtoms(formula));
+        const atoms = Array.from(collectAtoms(formula)).sort();
+        const n = atoms.length;
+        // Fast path: bitset finds countermodel in one pass
+        if (isPurePropositional(formula) && n <= 18) {
+            const { result, allOnes } = evaluateBitset(formula, atoms);
+            if (bvEquals(result, allOnes)) {
+                return {
+                    status: 'valid',
+                    output: `${formulaToString(formula)} es tautologia, no hay contramodelo`,
+                    diagnostics: [],
+                    formula,
+                };
+            }
+            // Find first 0 bit (first falsifying row)
+            const inverted = bvNot(result, allOnes);
+            const idx = bvFirstSet(inverted);
+            const v = {};
+            for (let j = 0; j < n; j++) {
+                v[atoms[j]] = Boolean((idx >> (n - 1 - j)) & 1);
+            }
+            const valStr = atoms.map((a) => `${a}=${v[a] ? 'V' : 'F'}`).join(', ');
+            return {
+                status: 'invalid',
+                output: `Contramodelo encontrado para ${formulaToString(formula)}\n  ← ${valStr}`,
+                model: { type: 'propositional', valuation: v },
+                diagnostics: [],
+                formula,
+            };
+        }
+        // Fallback: classic evaluation
         const valuations = generateValuations(atoms);
         for (const v of valuations) {
-            if (!evaluate(formula, v)) {
-                // #25: mark the countermodel valuation with ←
+            if (!evaluateClassical(formula, v)) {
                 const valStr = atoms.map((a) => `${a}=${v[a] ? 'V' : 'F'}`).join(', ');
                 return {
                     status: 'invalid',
@@ -1296,17 +1558,54 @@ class ClassicalPropositional {
     }
     truthTable(formula) {
         const atoms = Array.from(collectAtoms(formula)).sort();
-        const valuations = generateValuations(atoms);
+        const n = atoms.length;
         const subForms = getSubFormulas(formula);
+        const subFormulasInfo = subForms.map((sf) => ({ formula: sf, label: formulaToString(sf) }));
+        // Fast path: bitset evaluation for pure propositional formulas
+        // Limit to n<=20 for row materialization (2^20 = ~1M rows)
+        if (isPurePropositional(formula) && n <= 20) {
+            const { result, atomMasks, total, allOnes } = evaluateBitset(formula, atoms);
+            const satisfyingCount = bitsetPopcount(result);
+            // Evaluate subformulas with bitsets too
+            const subBitsets = subForms.map((sf) => isPurePropositional(sf) ? evaluateBitset(sf, atoms).result : bvCreate(total));
+            // Materialize rows from bitset results
+            const rows = new Array(total);
+            for (let i = 0; i < total; i++) {
+                const v = {};
+                for (let j = 0; j < n; j++) {
+                    v[atoms[j]] = bvTestBit(atomMasks.get(atoms[j]), i);
+                }
+                rows[i] = { valuation: v, result: bvTestBit(result, i) };
+            }
+            const subFormulaValues = rows.map((_, i) => {
+                const vals = {};
+                subForms.forEach((sf, si) => {
+                    vals[formulaToString(sf)] = bvTestBit(subBitsets[si], i);
+                });
+                return vals;
+            });
+            return {
+                variables: atoms,
+                rows,
+                isTautology: bvEquals(result, allOnes),
+                isContradiction: bvIsZero(result),
+                isSatisfiable: !bvIsZero(result),
+                subFormulas: subFormulasInfo,
+                subFormulaValues,
+                satisfyingCount,
+                totalCount: total,
+            };
+        }
+        // Fallback: classic evaluation
+        const valuations = generateValuations(atoms);
         const rows = valuations.map((v) => ({
             valuation: v,
-            result: evaluate(formula, v),
+            result: evaluateClassical(formula, v),
         }));
-        const subFormulasInfo = subForms.map((sf) => ({ formula: sf, label: formulaToString(sf) }));
         const subFormulaValues = valuations.map((v) => {
             const vals = {};
             subForms.forEach((sf) => {
-                vals[formulaToString(sf)] = evaluate(sf, v);
+                vals[formulaToString(sf)] = evaluateClassical(sf, v);
             });
             return vals;
         });
@@ -1317,7 +1616,7 @@ class ClassicalPropositional {
             isContradiction: rows.every((r) => !r.result),
             isSatisfiable: rows.some((r) => r.result),
             subFormulas: subFormulasInfo,
-            subFormulaValues: subFormulaValues,
+            subFormulaValues,
             satisfyingCount: rows.filter((r) => r.result).length,
             totalCount: rows.length,
         };