@stevenvo780/st-lang 2.6.1 → 2.7.1

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;
@@ -12,7 +14,9 @@ exports.toDNF = toDNF;
 exports.extractClauses = extractClauses;
 const formula_classifier_1 = require("../../runtime/formula-classifier");
 const format_1 = require("../../runtime/format");
+const educational_notes_1 = require("../../runtime/educational-notes");
 const memo_1 = require("../../utils/memo");
+const dpll_1 = require("./dpll");
 // --- Utilidades de fórmulas ---
 function collectAtoms(f) {
     return (0, memo_1.memoizeAtoms)(f, computeCollectAtoms);
@@ -32,39 +36,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}`);
@@ -79,8 +83,8 @@ function generateValuations(atoms) {
     const n = atoms.length;
     if (n === 0)
         return [{}];
-    if (n > 20)
-        throw new Error('Demasiadas variables para tabla de verdad (>20)');
+    if (n > 23)
+        throw new Error('Demasiadas variables para tabla de verdad (>23)');
     const total = 1 << n;
     const valuations = new Array(total);
     for (let i = 0; i < total; i++) {
@@ -93,6 +97,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 +401,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 +536,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 +567,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 +1128,67 @@ 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 if (allPure && atomList.length > 26) {
+            // DPLL fallback for >26 atoms
+            // Build: (premise1 & premise2 & ... & premiseN) -> goal
+            // Valid iff NOT satisfiable: (premises & !goal)
+            let conjunction = allAxiomFormulas[0];
+            for (let i = 1; i < allAxiomFormulas.length; i++) {
+                conjunction = { kind: 'and', args: [conjunction, allAxiomFormulas[i]] };
+            }
+            const negGoal = { kind: 'not', args: [goal] };
+            const check = { kind: 'and', args: [conjunction, negGoal] };
+            const result = (0, dpll_1.dpll)(check);
+            if (!result.satisfiable) {
+                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,24 +1283,56 @@ 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`,
+                educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'valid', valid: isValid }),
+                diagnostics: [],
+                formula,
+            };
+        }
+        // DPLL path: for formulas with >26 atoms, use SAT solver
+        if (isPurePropositional(formula) && atoms.length > 26) {
+            const negated = { kind: 'not', args: [formula] };
+            const result = (0, dpll_1.dpll)(negated);
+            const isValid = !result.satisfiable;
+            return {
+                status: isValid ? 'valid' : 'invalid',
+                output: isValid
+                    ? `${formulaToString(formula)} es VALIDA (tautologia)`
+                    : `${formulaToString(formula)} NO es valida`,
+                model: !isValid && result.model ? { type: 'propositional', valuation: result.model } : undefined,
+                educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'valid', valid: isValid }),
+                diagnostics: [],
+                formula,
+            };
+        }
         const tt = this.truthTable(formula);
         if (tt.isTautology) {
             return {
                 status: 'valid',
                 output: `${formulaToString(formula)} es VALIDA (tautologia)`,
                 truthTable: tt,
+                educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'valid', valid: true }),
                 diagnostics: [],
                 formula,
             };
         }
         else {
-            // Encontrar contramodelo
             const cm = tt.rows.find((r) => !r.result);
             return {
                 status: 'invalid',
                 output: `${formulaToString(formula)} NO es valida`,
                 truthTable: tt,
                 model: cm ? { type: 'propositional', valuation: cm.valuation } : undefined,
+                educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'valid', valid: false }),
                 diagnostics: [],
                 formula,
             };
@@ -1082,6 +1343,37 @@ 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)`,
+                educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'satisfiable', sat: isSat }),
+                diagnostics: [],
+                formula,
+            };
+        }
+        // DPLL path: for formulas with >26 atoms, use SAT solver
+        if (isPurePropositional(formula) && atoms.length > 26) {
+            const result = (0, dpll_1.dpll)(formula);
+            return {
+                status: result.satisfiable ? 'satisfiable' : 'unsatisfiable',
+                output: result.satisfiable
+                    ? `${formulaToString(formula)} es SATISFACIBLE`
+                    : `${formulaToString(formula)} es INSATISFACIBLE (contradiccion)`,
+                model: result.satisfiable && result.model
+                    ? { type: 'propositional', valuation: result.model }
+                    : undefined,
+                educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'satisfiable', sat: result.satisfiable }),
+                diagnostics: [],
+                formula,
+            };
+        }
         const tt = this.truthTable(formula);
         if (tt.isSatisfiable) {
             const sat = tt.rows.find((r) => r.result);
@@ -1090,6 +1382,7 @@ class ClassicalPropositional {
                 output: `${formulaToString(formula)} es SATISFACIBLE`,
                 model: sat ? { type: 'propositional', valuation: sat.valuation } : undefined,
                 truthTable: tt,
+                educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'satisfiable', sat: true }),
                 diagnostics: [],
                 formula,
             };
@@ -1099,6 +1392,7 @@ class ClassicalPropositional {
                 status: 'unsatisfiable',
                 output: `${formulaToString(formula)} es INSATISFACIBLE (contradiccion)`,
                 truthTable: tt,
+                educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'satisfiable', sat: false }),
                 diagnostics: [],
                 formula,
             };
@@ -1116,6 +1410,7 @@ class ClassicalPropositional {
                 status: 'provable',
                 output: `${formulaToString(goal)} es DEMOSTRABLE desde la teoria`,
                 proof,
+                educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'prove', ok: true }),
                 diagnostics: [],
                 formula: goal,
             };
@@ -1123,6 +1418,7 @@ class ClassicalPropositional {
         return {
             status: 'refutable',
             output: `${formulaToString(goal)} NO es demostrable desde la teoria dada`,
+            educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'prove', ok: false }),
             diagnostics: [],
             formula: goal,
         };
@@ -1154,7 +1450,12 @@ class ClassicalPropositional {
                         : rulesUsed.has('Silogismo Hipotetico')
                             ? 'φ → ψ, ψ → χ ⊢ φ → χ'
                             : undefined,
-                educationalNote: `Consecuencia semántica (⊨): Verificada — no existe valuación donde las premisas sean V y la conclusión F.\nConsecuencia sintáctica (⊢): Derivación formal completada en ${proof.steps.length} pasos.\nNota: Por completitud de la lógica proposicional clásica, ⊨ y ⊢ coinciden.`,
+                educationalNote: (0, educational_notes_1.pickEducationalNote)({
+                    op: 'derive',
+                    ok: true,
+                    steps: proof.steps.length,
+                    rules: Array.from(rulesUsed),
+                }),
                 diagnostics: [],
                 formula: goal,
             };
@@ -1162,6 +1463,7 @@ class ClassicalPropositional {
         return {
             status: 'refutable',
             output: `No se puede derivar ${formulaToString(goal)} desde las premisas dadas`,
+            educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'derive', ok: false }),
             diagnostics: [],
             formula: goal,
         };
@@ -1171,16 +1473,70 @@ 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 <= 26) {
+            const { result, allOnes } = evaluateBitset(formula, atoms);
+            if (bvEquals(result, allOnes)) {
+                return {
+                    status: 'valid',
+                    output: `${formulaToString(formula)} es tautologia, no hay contramodelo`,
+                    educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'countermodel', found: false }),
+                    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 },
+                educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'countermodel', found: true }),
+                diagnostics: [],
+                formula,
+            };
+        }
+        // DPLL path: for formulas with >26 atoms, use SAT solver to find countermodel
+        if (isPurePropositional(formula) && n > 26) {
+            const negated = { kind: 'not', args: [formula] };
+            const result = (0, dpll_1.dpll)(negated);
+            if (result.satisfiable && result.model) {
+                const valStr = atoms.map((a) => `${a}=${result.model[a] ? 'V' : 'F'}`).join(', ');
+                return {
+                    status: 'invalid',
+                    output: `Contramodelo encontrado para ${formulaToString(formula)}\n  ← ${valStr}`,
+                    model: { type: 'propositional', valuation: result.model },
+                    educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'countermodel', found: true }),
+                    diagnostics: [],
+                    formula,
+                };
+            }
+            return {
+                status: 'valid',
+                output: `${formulaToString(formula)} es tautologia, no hay contramodelo`,
+                educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'countermodel', found: false }),
+                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',
                     output: `Contramodelo encontrado para ${formulaToString(formula)}\n  ← ${valStr}`,
                     model: { type: 'propositional', valuation: v },
+                    educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'countermodel', found: true }),
                     diagnostics: [],
                     formula,
                 };
@@ -1189,6 +1545,7 @@ class ClassicalPropositional {
         return {
             status: 'valid',
             output: `${formulaToString(formula)} es tautologia, no hay contramodelo`,
+            educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'countermodel', found: false }),
             diagnostics: [],
             formula,
         };
@@ -1296,17 +1653,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 +1711,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,
         };
@@ -1335,6 +1729,7 @@ class ClassicalPropositional {
                 status: 'valid',
                 output: `${formulaToString(a)} y ${formulaToString(b)} son EQUIVALENTES`,
                 truthTable: tt,
+                educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'equivalent', equiv: true }),
                 diagnostics: [],
             };
         }
@@ -1343,6 +1738,7 @@ class ClassicalPropositional {
             status: 'invalid',
             output: `${formulaToString(a)} y ${formulaToString(b)} NO son equivalentes`,
             model: cm ? { type: 'propositional', valuation: cm.valuation } : undefined,
+            educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'equivalent', equiv: false }),
             diagnostics: [],
         };
     }