@stevenvo780/st-lang 4.6.0 → 4.8.0

package/dist/logic/profiles/classical/propositional.js

@@ -0,0 +1,2868 @@
+"use strict";
+// ============================================================
+// ST Classical Propositional — Motor completo
+// ============================================================
+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;
+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);
+}
+function computeCollectAtoms(f) {
+    const atoms = new Set();
+    function walk(node) {
+        if (node.kind === 'atom' && node.name) {
+            atoms.add(node.name);
+        }
+        if (node.args) {
+            for (const arg of node.args) {
+                walk(arg);
+            }
+        }
+    }
+    walk(f);
+    return atoms;
+}
+function evaluateClassical(f, v) {
+    switch (f.kind) {
+        case 'true':
+            return true;
+        case 'false':
+            return false;
+        case 'atom':
+            return f.name ? (v[f.name] ?? false) : false;
+        case 'not':
+            return f.args && f.args[0] ? !evaluateClassical(f.args[0], v) : false;
+        case 'and':
+            return f.args && f.args[0] && f.args[1]
+                ? evaluateClassical(f.args[0], v) && evaluateClassical(f.args[1], v)
+                : false;
+        case 'or':
+            return f.args && f.args[0] && f.args[1]
+                ? evaluateClassical(f.args[0], v) || evaluateClassical(f.args[1], v)
+                : false;
+        case 'implies':
+            return f.args && f.args[0] && f.args[1]
+                ? !evaluateClassical(f.args[0], v) || evaluateClassical(f.args[1], v)
+                : false;
+        case 'biconditional':
+            return f.args && f.args[0] && f.args[1]
+                ? evaluateClassical(f.args[0], v) === evaluateClassical(f.args[1], v)
+                : false;
+        case 'nand':
+            return f.args && f.args[0] && f.args[1]
+                ? !(evaluateClassical(f.args[0], v) && evaluateClassical(f.args[1], v))
+                : false;
+        case 'nor':
+            return f.args && f.args[0] && f.args[1]
+                ? !(evaluateClassical(f.args[0], v) || evaluateClassical(f.args[1], v))
+                : false;
+        case 'xor':
+            return f.args && f.args[0] && f.args[1]
+                ? 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}`);
+    }
+}
+/**
+ * Optimización: Generar valuaciones de forma más eficiente.
+ * Usa bitsets implícitos para evitar recrear objetos innecesariamente si fuera posible,
+ * pero aquí mantenemos la interfaz de Valuation (objeto) por compatibilidad.
+ */
+function generateValuations(atoms) {
+    const n = atoms.length;
+    if (n === 0)
+        return [{}];
+    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++) {
+        const v = {};
+        for (let j = 0; j < n; j++) {
+            // Usar bitwise para determinar el valor de verdad
+            v[atoms[j]] = Boolean((i >> (n - 1 - j)) & 1);
+        }
+        valuations[i] = v;
+    }
+    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;
+    }
+    if (n > 23)
+        throw new Error('Demasiadas variables para tabla de verdad (>23)');
+    const total = 2 ** n;
+    for (let i = 0; i < total; i++) {
+        const v = {};
+        for (let j = 0; j < n; j++) {
+            const divisor = 2 ** (n - 1 - j);
+            v[atoms[j]] = Math.floor(i / divisor) % 2 === 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': {
+                const [inner] = f.args ?? [];
+                return bvNot(evalBits(inner), allOnes);
+            }
+            case 'and': {
+                const [left, right] = f.args ?? [];
+                return bvAnd(evalBits(left), evalBits(right));
+            }
+            case 'or': {
+                const [left, right] = f.args ?? [];
+                return bvOr(evalBits(left), evalBits(right));
+            }
+            case 'implies': {
+                const [left, right] = f.args ?? [];
+                return bvOr(bvNot(evalBits(left), allOnes), evalBits(right));
+            }
+            case 'biconditional': {
+                const [left, right] = f.args ?? [];
+                return bvNot(bvXor(evalBits(left), evalBits(right)), allOnes);
+            }
+            case 'xor': {
+                const [left, right] = f.args ?? [];
+                return bvXor(evalBits(left), evalBits(right));
+            }
+            case 'nand': {
+                const [left, right] = f.args ?? [];
+                return bvNot(bvAnd(evalBits(left), evalBits(right)), allOnes);
+            }
+            case 'nor': {
+                const [left, right] = f.args ?? [];
+                return bvNot(bvOr(evalBits(left), evalBits(right)), 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]
+ */
+function collectAssociativeArgs(f, kind) {
+    if (f.kind !== kind || !f.args?.length)
+        return [f];
+    const items = [];
+    for (const arg of f.args) {
+        if (!arg)
+            continue;
+        items.push(...collectAssociativeArgs(arg, kind));
+    }
+    return items;
+}
+function formulaToString(f) {
+    return (0, memo_1.memoizeString)(f, computeFormulaToString);
+}
+function computeFormulaToString(f) {
+    switch (f.kind) {
+        case 'true':
+            return '⊤';
+        case 'false':
+            return '⊥';
+        case 'atom':
+            return f.name || '?';
+        case 'not': {
+            const inner = f.args?.[0];
+            if (!inner)
+                return '!?';
+            if (inner.kind === 'atom')
+                return `!${formulaToString(inner)}`;
+            return `!(${formulaToString(inner)})`;
+        }
+        case 'and':
+            return f.args && f.args[0] && f.args[1]
+                ? `(${collectAssociativeArgs(f, 'and').map(formulaToString).join(' & ')})`
+                : '? & ?';
+        case 'or':
+            return f.args && f.args[0] && f.args[1]
+                ? `(${collectAssociativeArgs(f, 'or').map(formulaToString).join(' | ')})`
+                : '? | ?';
+        case 'implies':
+            return f.args && f.args[0] && f.args[1]
+                ? `(${formulaToString(f.args[0])} -> ${formulaToString(f.args[1])})`
+                : '? -> ?';
+        case 'biconditional':
+            return f.args && f.args[0] && f.args[1]
+                ? `(${formulaToString(f.args[0])} <-> ${formulaToString(f.args[1])})`
+                : '? <-> ?';
+        case 'nand':
+            return f.args && f.args[0] && f.args[1]
+                ? `(${formulaToString(f.args[0])} ↑ ${formulaToString(f.args[1])})`
+                : '? ↑ ?';
+        case 'nor':
+            return f.args && f.args[0] && f.args[1]
+                ? `(${formulaToString(f.args[0])} ↓ ${formulaToString(f.args[1])})`
+                : '? ↓ ?';
+        case 'xor':
+            return f.args && f.args[0] && f.args[1]
+                ? `(${collectAssociativeArgs(f, 'xor').map(formulaToString).join(' ⊕ ')})`
+                : '? ⊕ ?';
+        case 'equals':
+            return f.args && f.args[0] && f.args[1]
+                ? `(${formulaToString(f.args[0])} = ${formulaToString(f.args[1])})`
+                : '? = ?';
+        case 'temporal_next':
+            return f.args?.[0] ? `X(${formulaToString(f.args[0])})` : 'X(?)';
+        case 'temporal_until':
+            return f.args && f.args[0] && f.args[1]
+                ? `(${formulaToString(f.args[0])} U ${formulaToString(f.args[1])})`
+                : '? U ?';
+        case 'modal_necessity':
+            return f.args?.[0] ? `[](${formulaToString(f.args[0])})` : '[](?)';
+        case 'modal_possibility':
+            return f.args?.[0] ? `<>(${formulaToString(f.args[0])})` : '<>(?)';
+        case 'forall':
+            return f.variable && f.args?.[0]
+                ? `forall ${f.variable}(${formulaToString(f.args[0])})`
+                : 'forall ?(?)';
+        case 'exists':
+            return f.variable && f.args?.[0]
+                ? `exists ${f.variable}(${formulaToString(f.args[0])})`
+                : 'exists ?(?)';
+        case 'predicate':
+            return f.name ? `${f.name}(${(f.params || []).join(', ')})` : '?(...)';
+        // Arithmetic
+        case 'number':
+            return f.value !== undefined ? String(f.value) : '?';
+        case 'add':
+            return f.args?.[0] && f.args?.[1]
+                ? `(${formulaToString(f.args[0])} + ${formulaToString(f.args[1])})`
+                : '? + ?';
+        case 'subtract':
+            return f.args?.[0] && f.args?.[1]
+                ? `(${formulaToString(f.args[0])} - ${formulaToString(f.args[1])})`
+                : '? - ?';
+        case 'multiply':
+            return f.args?.[0] && f.args?.[1]
+                ? `(${formulaToString(f.args[0])} * ${formulaToString(f.args[1])})`
+                : '? * ?';
+        case 'divide':
+            return f.args?.[0] && f.args?.[1]
+                ? `(${formulaToString(f.args[0])} / ${formulaToString(f.args[1])})`
+                : '? / ?';
+        case 'modulo':
+            return f.args?.[0] && f.args?.[1]
+                ? `(${formulaToString(f.args[0])} % ${formulaToString(f.args[1])})`
+                : '? % ?';
+        case 'less':
+            return f.args?.[0] && f.args?.[1]
+                ? `(${formulaToString(f.args[0])} < ${formulaToString(f.args[1])})`
+                : '? < ?';
+        case 'greater':
+            return f.args?.[0] && f.args?.[1]
+                ? `(${formulaToString(f.args[0])} > ${formulaToString(f.args[1])})`
+                : '? > ?';
+        case 'less_eq':
+            return f.args?.[0] && f.args?.[1]
+                ? `(${formulaToString(f.args[0])} <= ${formulaToString(f.args[1])})`
+                : '? <= ?';
+        case 'greater_eq':
+            return f.args?.[0] && f.args?.[1]
+                ? `(${formulaToString(f.args[0])} >= ${formulaToString(f.args[1])})`
+                : '? >= ?';
+        default:
+            return '?';
+    }
+}
+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 || [];
+        if (!negated) {
+            switch (k) {
+                case 'true':
+                case 'false':
+                case 'atom':
+                case 'predicate':
+                    return node;
+                case 'not':
+                    return simplify(args[0], true);
+                case 'and':
+                case 'or':
+                case 'implies':
+                case 'biconditional':
+                case 'modal_necessity':
+                case 'modal_possibility':
+                case 'temporal_next':
+                case 'forall':
+                case 'exists':
+                    return { ...node, args: args.map((a) => simplify(a, false)) };
+                case 'nand':
+                    return simplify({
+                        kind: 'or',
+                        args: [
+                            { kind: 'not', args: [args[0]] },
+                            { kind: 'not', args: [args[1]] },
+                        ],
+                    }, false);
+                case 'nor':
+                    return simplify({
+                        kind: 'and',
+                        args: [
+                            { kind: 'not', args: [args[0]] },
+                            { kind: 'not', args: [args[1]] },
+                        ],
+                    }, false);
+                case 'xor':
+                    return simplify({
+                        kind: 'or',
+                        args: [
+                            { kind: 'and', args: [args[0], { kind: 'not', args: [args[1]] }] },
+                            { kind: 'and', args: [{ kind: 'not', args: [args[0]] }, args[1]] },
+                        ],
+                    }, false);
+            }
+        }
+        else {
+            switch (k) {
+                case 'true':
+                    return { kind: 'false' };
+                case 'false':
+                    return { kind: 'true' };
+                case 'atom':
+                case 'predicate':
+                    return { kind: 'not', args: [node] };
+                case 'not':
+                    return simplify(args[0], false);
+                case 'and':
+                    return { kind: 'or', args: args.map((a) => simplify(a, true)) };
+                case 'or':
+                    return { kind: 'and', args: args.map((a) => simplify(a, true)) };
+                case 'implies':
+                    // !(A -> B)  =>  A & !B
+                    return { kind: 'and', args: [simplify(args[0], false), simplify(args[1], true)] };
+                case 'biconditional':
+                    // !(A <-> B) => (A & !B) | (!A & B)
+                    return simplify({
+                        kind: 'or',
+                        args: [
+                            { kind: 'and', args: [args[0], { kind: 'not', args: [args[1]] }] },
+                            { kind: 'and', args: [{ kind: 'not', args: [args[0]] }, args[1]] },
+                        ],
+                    }, false);
+                case 'nand':
+                    // !(A nand B) => A & B
+                    return simplify({ kind: 'and', args: [args[0], args[1]] }, false);
+                case 'nor':
+                    // !(A nor B) => A | B
+                    return simplify({ kind: 'or', args: [args[0], args[1]] }, false);
+                case 'xor':
+                    // !(A xor B) => A <-> B
+                    return simplify({ kind: 'biconditional', args: [args[0], args[1]] }, false);
+                case 'modal_necessity':
+                    return { kind: 'modal_possibility', args: [simplify(args[0], true)] };
+                case 'modal_possibility':
+                    return { kind: 'modal_necessity', args: [simplify(args[0], true)] };
+                case 'temporal_next':
+                    // ¬X(φ) ≡ X(¬φ) — next conmuta con negación en LTL
+                    return { kind: 'temporal_next', args: [simplify(args[0], true)] };
+                case 'forall':
+                    return {
+                        kind: 'exists',
+                        variable: node.variable,
+                        args: [simplify(args[0], true)],
+                    };
+                case 'exists':
+                    return {
+                        kind: 'forall',
+                        variable: node.variable,
+                        args: [simplify(args[0], true)],
+                    };
+            }
+        }
+        return node;
+    };
+    return simplify(f, false);
+}
+function distributeOrOverAnd(f) {
+    if (f.kind === 'or' && f.args?.[0] && f.args?.[1]) {
+        const l = distributeOrOverAnd(f.args[0]);
+        const r = distributeOrOverAnd(f.args[1]);
+        if (l.kind === 'and' && l.args?.[0] && l.args?.[1]) {
+            return {
+                kind: 'and',
+                args: [
+                    distributeOrOverAnd({ kind: 'or', args: [l.args[0], r] }),
+                    distributeOrOverAnd({ kind: 'or', args: [l.args[1], r] }),
+                ],
+            };
+        }
+        if (r.kind === 'and' && r.args?.[0] && r.args?.[1]) {
+            return {
+                kind: 'and',
+                args: [
+                    distributeOrOverAnd({ kind: 'or', args: [l, r.args[0]] }),
+                    distributeOrOverAnd({ kind: 'or', args: [l, r.args[1]] }),
+                ],
+            };
+        }
+        return { kind: 'or', args: [l, r] };
+    }
+    if (f.args)
+        return { ...f, args: f.args.map((a) => (a ? distributeOrOverAnd(a) : a)) };
+    return f;
+}
+function toCNF(f) {
+    return (0, memo_1.memoizeCNF)(f, (formula) => distributeOrOverAnd(toNNF(formula)));
+}
+function distributeAndOverOr(f) {
+    if (f.kind === 'and' && f.args?.[0] && f.args?.[1]) {
+        const l = distributeAndOverOr(f.args[0]);
+        const r = distributeAndOverOr(f.args[1]);
+        if (l.kind === 'or' && l.args?.[0] && l.args?.[1]) {
+            return {
+                kind: 'or',
+                args: [
+                    distributeAndOverOr({ kind: 'and', args: [l.args[0], r] }),
+                    distributeAndOverOr({ kind: 'and', args: [l.args[1], r] }),
+                ],
+            };
+        }
+        if (r.kind === 'or' && r.args?.[0] && r.args?.[1]) {
+            return {
+                kind: 'or',
+                args: [
+                    distributeAndOverOr({ kind: 'and', args: [l, r.args[0]] }),
+                    distributeAndOverOr({ kind: 'and', args: [l, r.args[1]] }),
+                ],
+            };
+        }
+        return { kind: 'and', args: [l, r] };
+    }
+    if (f.args)
+        return { ...f, args: f.args.map((a) => (a ? distributeAndOverOr(a) : a)) };
+    return f;
+}
+function toDNF(f) {
+    return (0, memo_1.memoizeDNF)(f, (formula) => distributeAndOverOr(toNNF(formula)));
+}
+/**
+ * Extracts clauses from a CNF formula for resolution analysis (#28)
+ * Returns an array of clauses, where each clause is an array of literals.
+ */
+function extractClauses(f) {
+    const cnf = toCNF(f);
+    const clauses = [];
+    const extractClause = (node) => {
+        if (node.kind === 'or') {
+            const lits = [];
+            for (const arg of node.args || []) {
+                lits.push(...extractClause(arg));
+            }
+            return lits;
+        }
+        if (node.kind === 'not' && node.args?.[0]) {
+            return [`¬${formulaToString(node.args[0])}`];
+        }
+        return [formulaToString(node)];
+    };
+    const extractClauses2 = (node) => {
+        if (node.kind === 'and') {
+            for (const arg of node.args || []) {
+                extractClauses2(arg);
+            }
+        }
+        else {
+            clauses.push(extractClause(node));
+        }
+    };
+    extractClauses2(cnf);
+    return clauses;
+}
+function getSubFormulas(f) {
+    const result = [];
+    const seen = new Set();
+    function walk(node) {
+        if (node.args)
+            node.args.forEach((a) => {
+                if (a)
+                    walk(a);
+            });
+        const hash = formulaToString(node);
+        if (!seen.has(hash)) {
+            seen.add(hash);
+            result.push(node);
+        }
+    }
+    walk(f);
+    // Remove atoms and the full formula itself
+    return result.filter((n) => n.kind !== 'atom' && formulaToString(n) !== formulaToString(f));
+}
+/**
+ * Igualdad estructural con alpha-equivalencia sobre variables cuantificadas.
+ * Cubre átomos, predicados, cuantificadores (∀/∃), modales y constantes.
+ */
+function formulasEqual(a, b) {
+    return alphaEqualFormulas(a, b, new Map(), new Map());
+}
+function alphaEqualFormulas(a, b, bindA, bindB, depth = 0) {
+    if (a.kind !== b.kind)
+        return false;
+    switch (a.kind) {
+        case 'true':
+        case 'false':
+            return true;
+        case 'atom': {
+            const nameA = a.name;
+            const nameB = b.name;
+            if (nameA === undefined || nameB === undefined)
+                return nameA === nameB;
+            const bA = bindA.get(nameA);
+            const bB = bindB.get(nameB);
+            if (bA !== undefined || bB !== undefined)
+                return bA === bB;
+            return nameA === nameB;
+        }
+        case 'number':
+            return a.value === b.value;
+        case 'predicate': {
+            if (a.name !== b.name)
+                return false;
+            const paramsA = a.params || a.terms || [];
+            const paramsB = b.params || b.terms || [];
+            if (paramsA.length !== paramsB.length)
+                return false;
+            for (let i = 0; i < paramsA.length; i++) {
+                const pA = paramsA[i];
+                const pB = paramsB[i];
+                const bndA = bindA.get(pA);
+                const bndB = bindB.get(pB);
+                if (bndA !== undefined || bndB !== undefined) {
+                    if (bndA !== bndB)
+                        return false;
+                }
+                else if (pA !== pB) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        case 'forall':
+        case 'exists': {
+            const vA = a.variable;
+            const vB = b.variable;
+            if (!vA || !vB)
+                return vA === vB;
+            const innerA = a.args?.[0];
+            const innerB = b.args?.[0];
+            if (!innerA || !innerB)
+                return false;
+            const prevA = bindA.get(vA);
+            const prevB = bindB.get(vB);
+            bindA.set(vA, depth);
+            bindB.set(vB, depth);
+            const eq = alphaEqualFormulas(innerA, innerB, bindA, bindB, depth + 1);
+            if (prevA === undefined)
+                bindA.delete(vA);
+            else
+                bindA.set(vA, prevA);
+            if (prevB === undefined)
+                bindB.delete(vB);
+            else
+                bindB.set(vB, prevB);
+            return eq;
+        }
+        case 'modal_necessity':
+        case 'modal_possibility':
+        case 'temporal_next':
+        case 'temporal_until': {
+            if (a.name !== b.name)
+                return false;
+            const argsA = a.args || [];
+            const argsB = b.args || [];
+            if (argsA.length !== argsB.length)
+                return false;
+            return argsA.every((arg, i) => alphaEqualFormulas(arg, argsB[i], bindA, bindB, depth));
+        }
+        default: {
+            const argsA = a.args || [];
+            const argsB = b.args || [];
+            if (argsA.length !== argsB.length)
+                return false;
+            if (argsA.length === 0) {
+                if (a.name !== b.name)
+                    return false;
+                return a.value === b.value;
+            }
+            return argsA.every((arg, i) => alphaEqualFormulas(arg, argsB[i], bindA, bindB, depth));
+        }
+    }
+}
+// --- Motor de derivación ---
+/** Límite duro de fórmulas derivadas para evitar explosión combinatoria */
+const MAX_KNOWN = 5000;
+/** Profundidad máxima de negación en cualquier sub-fórmula */
+function maxNegationDepth(f) {
+    if (f.kind === 'not' && f.args?.[0]) {
+        return 1 + maxNegationDepth(f.args[0]);
+    }
+    if (f.args) {
+        let max = 0;
+        for (const a of f.args) {
+            if (a) {
+                const d = maxNegationDepth(a);
+                if (d > max)
+                    max = d;
+            }
+        }
+        return max;
+    }
+    return 0;
+}
+function formulaHash(f) {
+    return formulaToString(f);
+}
+/** Check if a formula is a sub-formula of the goal (prevents explosive rule cascading) */
+function isRelevantToGoal(f, goal) {
+    const goalHash = formulaHash(goal);
+    const fHash = formulaHash(f);
+    if (fHash === goalHash)
+        return true;
+    // Check if f appears as sub-formula of goal
+    const checkSub = (node) => {
+        if (formulaHash(node) === fHash)
+            return true;
+        if (node.args)
+            return node.args.some(checkSub);
+        return false;
+    };
+    return checkSub(goal);
+}
+function addDerivedFormula(state, formula, justification, premises, source = 'rule') {
+    const hash = formulaHash(formula);
+    if (state.known.has(hash)) {
+        const variants = state.alternativeDerivations.get(hash) ?? [];
+        const isDuplicate = variants.some((variant) => variant.justification === justification &&
+            variant.source === source &&
+            variant.premises.length === premises.length &&
+            variant.premises.every((premise, index) => premise === premises[index]));
+        if (!isDuplicate) {
+            variants.push({ justification, premises: [...premises], source });
+            state.alternativeDerivations.set(hash, variants);
+        }
+        return false;
+    }
+    state.stepCount++;
+    state.steps.push({
+        stepNumber: state.stepCount,
+        formula,
+        justification,
+        premises,
+        source,
+    });
+    state.known.set(hash, formula);
+    state.formulas.push(formula);
+    state.stepByHash.set(hash, state.stepCount);
+    return true;
+}
+function buildPremiseRefs(theory, premiseNames) {
+    return premiseNames.map((name) => ({
+        name,
+        location: (theory.axioms.get(name) || theory.theorems.get(name))?.source,
+    }));
+}
+function buildProof(goal, steps, premiseNames, theory, method = 'natural_deduction', subproofs, metadataExtras = {}) {
+    const metadata = {
+        createdAt: new Date().toISOString(),
+        profile: theory.profile,
+        ...metadataExtras,
+    };
+    return {
+        goal,
+        steps,
+        status: 'complete',
+        derivedFrom: premiseNames,
+        premiseRefs: buildPremiseRefs(theory, premiseNames),
+        method,
+        subproofs: subproofs ? [...subproofs] : undefined,
+        metadata,
+    };
+}
+function buildDerivationMetadata(state, retainedSteps, semanticFallback = false) {
+    const sampledAlternatives = Array.from(state.alternativeDerivations.entries())
+        .filter(([, variants]) => variants.length > 0)
+        .sort((left, right) => right[1].length - left[1].length)
+        .slice(0, 12)
+        .map(([hash, variants]) => ({
+        formula: hash,
+        primaryStep: state.stepByHash.get(hash) ?? 0,
+        variants: variants.slice(0, 6).map((variant) => ({
+            justification: variant.justification,
+            premises: [...variant.premises],
+            source: variant.source,
+        })),
+    }));
+    const alternativeDerivationCount = Array.from(state.alternativeDerivations.values()).reduce((count, variants) => count + variants.length, 0);
+    return {
+        exploredStepCount: state.steps.length,
+        retainedStepCount: retainedSteps.length,
+        uniqueFormulaCount: state.formulas.length,
+        alternativeDerivationCount,
+        alternativeDerivationSamples: sampledAlternatives,
+        semanticFallback,
+    };
+}
+function buildCompositeDerivationMetadata(state, retainedSteps, subProofs = [], semanticFallback = false) {
+    const baseMetadata = buildDerivationMetadata(state, retainedSteps, semanticFallback);
+    const baseExploredStepCount = Number(baseMetadata.exploredStepCount ?? 0);
+    const baseAlternativeDerivationCount = Number(baseMetadata.alternativeDerivationCount ?? 0);
+    const subExploredStepCount = subProofs.reduce((count, subProof) => {
+        const subMetadata = subProof.metadata ?? {};
+        const explored = Number(subMetadata.exploredStepCount ?? subProof.steps.length);
+        return count + explored;
+    }, 0);
+    const subAlternativeDerivationCount = subProofs.reduce((count, subProof) => {
+        const subMetadata = subProof.metadata ?? {};
+        const alternatives = Number(subMetadata.alternativeDerivationCount ?? 0);
+        return count + alternatives;
+    }, 0);
+    const exploredStepCount = baseExploredStepCount + subExploredStepCount;
+    const alternativeDerivationCount = baseAlternativeDerivationCount + subAlternativeDerivationCount;
+    return {
+        ...baseMetadata,
+        exploredStepCount,
+        retainedStepCount: retainedSteps.length,
+        alternativeDerivationCount,
+        alternativeDerivationSamples: [],
+    };
+}
+function isNegationOf(a, b) {
+    return a.kind === 'not' && !!a.args?.[0] && formulasEqual(a.args[0], b);
+}
+function areComplementary(a, b) {
+    return isNegationOf(a, b) || isNegationOf(b, a);
+}
+function isExcludedMiddleFormula(formula) {
+    if (formula.kind !== 'or' || !formula.args?.[0] || !formula.args?.[1])
+        return false;
+    return (isNegationOf(formula.args[0], formula.args[1]) || isNegationOf(formula.args[1], formula.args[0]));
+}
+function buildSingleAssumptionProof(premiseSteps, assumption, assumptionJustification, subProof, goal, finalJustification) {
+    const mainSteps = [];
+    let stepNum = 0;
+    for (const s of premiseSteps) {
+        if (s.source === 'premise') {
+            stepNum++;
+            mainSteps.push({ ...s, stepNumber: stepNum, premises: [] });
+        }
+    }
+    stepNum++;
+    const assumptionStepNum = stepNum;
+    mainSteps.push({
+        stepNumber: stepNum,
+        formula: assumption,
+        justification: assumptionJustification,
+        premises: [],
+        source: 'assumption',
+    });
+    const subStepMap = new Map();
+    for (const s of subProof.steps) {
+        if (s.source === 'premise' && formulasEqual(s.formula, assumption)) {
+            subStepMap.set(s.stepNumber, assumptionStepNum);
+            continue;
+        }
+        if (s.source === 'premise') {
+            const existing = mainSteps.find((ms) => ms.source === 'premise' && formulasEqual(ms.formula, s.formula));
+            if (existing) {
+                subStepMap.set(s.stepNumber, existing.stepNumber);
+                continue;
+            }
+        }
+        stepNum++;
+        subStepMap.set(s.stepNumber, stepNum);
+        mainSteps.push({
+            stepNumber: stepNum,
+            formula: s.formula,
+            justification: s.justification,
+            premises: s.premises.map((p) => subStepMap.get(p) || p),
+            source: s.source,
+        });
+    }
+    stepNum++;
+    const subGoalStepNum = subStepMap.get(subProof.steps[subProof.steps.length - 1]?.stepNumber ?? 0) ?? stepNum - 1;
+    mainSteps.push({
+        stepNumber: stepNum,
+        formula: goal,
+        justification: finalJustification,
+        premises: [assumptionStepNum, subGoalStepNum],
+        subproofs: [subProof],
+        source: 'rule',
+    });
+    return mainSteps;
+}
+function buildMergedGoalProof(premiseSteps, subProofs, goal, finalJustification) {
+    const mainSteps = [];
+    let stepNum = 0;
+    const baseStepByHash = new Map();
+    for (const s of premiseSteps) {
+        if (s.source === 'premise') {
+            stepNum++;
+            mainSteps.push({ ...s, stepNumber: stepNum, premises: [] });
+            baseStepByHash.set(formulaHash(s.formula), stepNum);
+        }
+    }
+    const finalPremises = [];
+    for (const subProof of subProofs) {
+        const stepMap = new Map();
+        for (const s of subProof.steps) {
+            const hash = formulaHash(s.formula);
+            if (s.source === 'premise' && baseStepByHash.has(hash)) {
+                stepMap.set(s.stepNumber, baseStepByHash.get(hash) ?? 0);
+                continue;
+            }
+            if (s.source !== 'assumption' && baseStepByHash.has(hash)) {
+                stepMap.set(s.stepNumber, baseStepByHash.get(hash) ?? 0);
+                continue;
+            }
+            stepNum++;
+            stepMap.set(s.stepNumber, stepNum);
+            mainSteps.push({
+                stepNumber: stepNum,
+                formula: s.formula,
+                justification: s.justification,
+                premises: s.premises.map((p) => stepMap.get(p) || p),
+                subproofs: s.subproofs ? [...s.subproofs] : undefined,
+                source: s.source,
+            });
+            if (s.source !== 'assumption') {
+                baseStepByHash.set(hash, stepNum);
+            }
+        }
+        const mappedFinal = stepMap.get(subProof.steps[subProof.steps.length - 1]?.stepNumber ?? 0);
+        if (mappedFinal)
+            finalPremises.push(mappedFinal);
+    }
+    stepNum++;
+    mainSteps.push({
+        stepNumber: stepNum,
+        formula: goal,
+        justification: finalJustification,
+        premises: finalPremises,
+        subproofs: subProofs,
+        source: 'rule',
+    });
+    return mainSteps;
+}
+function buildKnownDerivationProof(state, formula, premiseNames, theory) {
+    const relevantSteps = traceBack(state.steps, formula);
+    return buildProof(formula, relevantSteps, premiseNames, theory, 'natural_deduction', undefined, buildDerivationMetadata(state, relevantSteps));
+}
+function getCommutativeVariant(formula) {
+    if ((formula.kind === 'and' || formula.kind === 'or') && formula.args?.[0] && formula.args?.[1]) {
+        return { kind: formula.kind, args: [formula.args[1], formula.args[0]] };
+    }
+    return null;
+}
+function getAssociativeVariants(formula) {
+    const variants = [];
+    if ((formula.kind === 'and' || formula.kind === 'or') && formula.args?.[0] && formula.args?.[1]) {
+        const [left, right] = formula.args;
+        if (left.kind === formula.kind && left.args?.[0] && left.args?.[1]) {
+            variants.push({
+                kind: formula.kind,
+                args: [left.args[0], { kind: formula.kind, args: [left.args[1], right] }],
+            });
+        }
+        if (right.kind === formula.kind && right.args?.[0] && right.args?.[1]) {
+            variants.push({
+                kind: formula.kind,
+                args: [{ kind: formula.kind, args: [left, right.args[0]] }, right.args[1]],
+            });
+        }
+    }
+    return variants;
+}
+function getAbsorptionResult(formula) {
+    if (formula.kind === 'and' && formula.args?.[0] && formula.args?.[1]) {
+        const [left, right] = formula.args;
+        if (right.kind === 'or' && right.args?.some((arg) => formulasEqual(arg, left)))
+            return left;
+        if (left.kind === 'or' && left.args?.some((arg) => formulasEqual(arg, right)))
+            return right;
+    }
+    if (formula.kind === 'or' && formula.args?.[0] && formula.args?.[1]) {
+        const [left, right] = formula.args;
+        if (right.kind === 'and' && right.args?.some((arg) => formulasEqual(arg, left)))
+            return left;
+        if (left.kind === 'and' && left.args?.some((arg) => formulasEqual(arg, right)))
+            return right;
+    }
+    return null;
+}
+function tryDerive(goal, theory, premiseNames, depth = 0) {
+    const state = {
+        known: new Map(),
+        formulas: [],
+        steps: [],
+        stepCount: 0,
+        stepByHash: new Map(),
+        alternativeDerivations: new Map(),
+    };
+    // Cargar premisas
+    for (const name of premiseNames) {
+        let f = theory.axioms.get(name) || theory.theorems.get(name);
+        // Fallback: if name not found directly, search for an axiom/theorem whose formula
+        // matches the bare atom name (e.g., premise "Q" matches a theorem whose formula is atom Q)
+        if (!f) {
+            for (const [, formula] of theory.axioms) {
+                if (formula.kind === 'atom' && formula.name === name) {
+                    f = formula;
+                    break;
+                }
+            }
+            if (!f) {
+                for (const [, formula] of theory.theorems) {
+                    if (formula.kind === 'atom' && formula.name === name) {
+                        f = formula;
+                        break;
+                    }
+                }
+            }
+        }
+        if (f) {
+            state.stepCount++;
+            state.steps.push({
+                stepNumber: state.stepCount,
+                formula: f,
+                justification: `Premisa (${name})`,
+                premises: [],
+                source: 'premise',
+            });
+            state.known.set(formulaHash(f), f);
+            state.formulas.push(f);
+            state.stepByHash.set(formulaHash(f), state.stepCount);
+        }
+    }
+    if (isExcludedMiddleFormula(goal)) {
+        addDerivedFormula(state, goal, 'Tercero excluido', []);
+    }
+    // Intentar derivar con BFS aplicando reglas (optimizado)
+    const maxIterations = 1000;
+    let changed = true;
+    let iterations = 0;
+    let lastProcessedIndex = 0;
+    while (changed && iterations < maxIterations && state.known.size < MAX_KNOWN) {
+        changed = false;
+        iterations++;
+        const currentFormulas = state.formulas;
+        const prevProcessedIndex = lastProcessedIndex;
+        lastProcessedIndex = currentFormulas.length;
+        for (let i = 0; i < currentFormulas.length; i++) {
+            const f1 = currentFormulas[i];
+            if (state.known.has(formulaHash(goal)))
+                break;
+            for (let j = 0; j < currentFormulas.length; j++) {
+                // Optimización crucial O(N^2 -> N): ignorar pares antiguos
+                if (i < prevProcessedIndex && j < prevProcessedIndex)
+                    continue;
+                const f2 = currentFormulas[j];
+                if (state.known.has(formulaHash(goal)))
+                    break;
+                // Contradicción explícita: de A y !A, derivar false (⊥)
+                if ((f1.kind === 'not' && f1.args?.[0] && formulasEqual(f1.args[0], f2)) ||
+                    (f2.kind === 'not' && f2.args?.[0] && formulasEqual(f2.args[0], f1))) {
+                    changed =
+                        addDerivedFormula(state, { kind: 'false' }, 'Contradiccion', [
+                            findStep(state.steps, f1),
+                            findStep(state.steps, f2),
+                        ]) || changed;
+                }
+                // Modus Ponens: de A y (A -> B), derivar B
+                if (f2.kind === 'implies' &&
+                    f2.args?.[0] &&
+                    f2.args?.[1] &&
+                    formulasEqual(f2.args[0], f1)) {
+                    const conclusion = f2.args[1];
+                    const s1 = findStep(state.steps, f1);
+                    const s2 = findStep(state.steps, f2);
+                    changed = addDerivedFormula(state, conclusion, 'Modus Ponens', [s1, s2]) || changed;
+                }
+                // Modus Ponens inverso: de (A -> B) y A, derivar B
+                if (f1.kind === 'implies' &&
+                    f1.args?.[0] &&
+                    f1.args?.[1] &&
+                    formulasEqual(f1.args[0], f2)) {
+                    const conclusion = f1.args[1];
+                    const s1 = findStep(state.steps, f1);
+                    const s2 = findStep(state.steps, f2);
+                    changed = addDerivedFormula(state, conclusion, 'Modus Ponens', [s1, s2]) || changed;
+                }
+                // Modus Tollens: de !B y (A -> B), derivar !A
+                if (f1.kind === 'not' &&
+                    f1.args?.[0] &&
+                    f2.kind === 'implies' &&
+                    f2.args?.[1] &&
+                    f2.args?.[0] &&
+                    formulasEqual(f1.args[0], f2.args[1])) {
+                    const conclusion = { kind: 'not', args: [f2.args[0]] };
+                    changed =
+                        addDerivedFormula(state, conclusion, 'Modus Tollens', [
+                            findStep(state.steps, f1),
+                            findStep(state.steps, f2),
+                        ]) || changed;
+                }
+                // Modus Tollens con consecuente negado: de B y (A -> !B), derivar !A
+                if (f2.kind === 'implies' &&
+                    f2.args?.[0] &&
+                    f2.args?.[1]?.kind === 'not' &&
+                    f2.args[1].args?.[0] &&
+                    formulasEqual(f1, f2.args[1].args[0])) {
+                    const conclusion = { kind: 'not', args: [f2.args[0]] };
+                    changed =
+                        addDerivedFormula(state, conclusion, 'Modus Tollens', [
+                            findStep(state.steps, f1),
+                            findStep(state.steps, f2),
+                        ]) || changed;
+                }
+                // Conjunction Introduction: de A y B, derivar A & B
+                // Only produce conjunctions that are relevant to the goal to avoid O(n²) explosion
+                if (f1 !== f2) {
+                    const conj = { kind: 'and', args: [f1, f2] };
+                    if (formulasEqual(conj, goal) || isRelevantToGoal(conj, goal)) {
+                        changed =
+                            addDerivedFormula(state, conj, 'Introduccion de conjuncion', [
+                                findStep(state.steps, f1),
+                                findStep(state.steps, f2),
+                            ]) || changed;
+                    }
+                }
+                // Silogismo hipotético: de (A -> B) y (B -> C), derivar (A -> C)
+                if (f1.kind === 'implies' &&
+                    f2.kind === 'implies' &&
+                    f1.args?.[0] &&
+                    f1.args?.[1] &&
+                    f2.args?.[0] &&
+                    f2.args?.[1] &&
+                    formulasEqual(f1.args[1], f2.args[0])) {
+                    const chained = { kind: 'implies', args: [f1.args[0], f2.args[1]] };
+                    changed =
+                        addDerivedFormula(state, chained, 'Silogismo hipotetico', [
+                            findStep(state.steps, f1),
+                            findStep(state.steps, f2),
+                        ]) || changed;
+                }
+                // Silogismo disyuntivo: de (A | B) y un complemento de A, derivar B /
+                // de un complemento de B, derivar A.
+                // Esto cubre tanto !A como fórmulas positivas que complementan un disyunto negado
+                // (p. ej. Q complementa a !Q).
+                if (f1.kind === 'or' && f1.args?.[0] && f1.args?.[1]) {
+                    if (areComplementary(f1.args[0], f2)) {
+                        changed =
+                            addDerivedFormula(state, f1.args[1], 'Silogismo disyuntivo', [
+                                findStep(state.steps, f1),
+                                findStep(state.steps, f2),
+                            ]) || changed;
+                    }
+                    if (areComplementary(f1.args[1], f2)) {
+                        changed =
+                            addDerivedFormula(state, f1.args[0], 'Silogismo disyuntivo', [
+                                findStep(state.steps, f1),
+                                findStep(state.steps, f2),
+                            ]) || changed;
+                    }
+                }
+                // Introducción de bicondicional: de (A -> B) y (B -> A), derivar (A <-> B)
+                if (f1.kind === 'implies' &&
+                    f2.kind === 'implies' &&
+                    f1.args?.[0] &&
+                    f1.args?.[1] &&
+                    f2.args?.[0] &&
+                    f2.args?.[1] &&
+                    formulasEqual(f1.args[0], f2.args[1]) &&
+                    formulasEqual(f1.args[1], f2.args[0])) {
+                    const biconditional = {
+                        kind: 'biconditional',
+                        args: [f1.args[0], f1.args[1]],
+                    };
+                    changed =
+                        addDerivedFormula(state, biconditional, 'Introduccion de bicondicional', [
+                            findStep(state.steps, f1),
+                            findStep(state.steps, f2),
+                        ]) || changed;
+                }
+                // Dilema Constructivo: de (P->Q)&(R->S) y P|R derivar Q|S
+                if (f1.kind === 'and' &&
+                    f1.args?.[0]?.kind === 'implies' &&
+                    f1.args?.[1]?.kind === 'implies' &&
+                    f2.kind === 'or' &&
+                    f2.args?.[0] &&
+                    f2.args?.[1] &&
+                    formulasEqual(f1.args[0].args[0], f2.args[0]) &&
+                    formulasEqual(f1.args[1].args[0], f2.args[1])) {
+                    const qs = {
+                        kind: 'or',
+                        args: [f1.args[0].args[1], f1.args[1].args[1]],
+                    };
+                    changed =
+                        addDerivedFormula(state, qs, 'Dilema Constructivo', [
+                            findStep(state.steps, f1),
+                            findStep(state.steps, f2),
+                        ]) || changed;
+                }
+                // Dilema Destructivo: de (P->Q)&(R->S) y !Q|!S derivar !P|!R
+                if (f1.kind === 'and' &&
+                    f1.args?.[0]?.kind === 'implies' &&
+                    f1.args?.[1]?.kind === 'implies' &&
+                    f2.kind === 'or' &&
+                    f2.args?.[0]?.kind === 'not' &&
+                    f2.args?.[1]?.kind === 'not' &&
+                    formulasEqual(f1.args[0].args[1], f2.args[0].args[0]) &&
+                    formulasEqual(f1.args[1].args[1], f2.args[1].args[0])) {
+                    const npnr = {
+                        kind: 'or',
+                        args: [
+                            { kind: 'not', args: [f1.args[0].args[0]] },
+                            { kind: 'not', args: [f1.args[1].args[0]] },
+                        ],
+                    };
+                    changed =
+                        addDerivedFormula(state, npnr, 'Dilema Destructivo', [
+                            findStep(state.steps, f1),
+                            findStep(state.steps, f2),
+                        ]) || changed;
+                }
+                // Dilema simple: P|Q, P->R, Q->R derivar R
+                if (f1.kind === 'or' &&
+                    f1.args?.[0] &&
+                    f1.args?.[1] &&
+                    f2.kind === 'implies' &&
+                    f2.args?.[0] &&
+                    formulasEqual(f1.args[0], f2.args[0])) {
+                    for (let k = 0; k < currentFormulas.length; k++) {
+                        if (i < prevProcessedIndex && j < prevProcessedIndex && k < prevProcessedIndex)
+                            continue;
+                        const f3 = currentFormulas[k];
+                        if (f3.kind === 'implies' &&
+                            f3.args?.[0] &&
+                            f3.args?.[1] &&
+                            formulasEqual(f1.args[1], f3.args[0]) &&
+                            formulasEqual(f2.args[1], f3.args[1])) {
+                            changed =
+                                addDerivedFormula(state, f2.args[1], 'Dilema Simple', [
+                                    findStep(state.steps, f1),
+                                    findStep(state.steps, f2),
+                                    findStep(state.steps, f3),
+                                ]) || changed;
+                            break; // solo una vez por par f1,f2
+                        }
+                    }
+                }
+                // Dilema Constructivo (implicaciones separadas): P->Q, R->S, P|R ⊢ Q|S
+                // No requiere que las implicaciones estén en conjunción
+                if (f1.kind === 'implies' &&
+                    f1.args?.[0] &&
+                    f1.args?.[1] &&
+                    f2.kind === 'implies' &&
+                    f2.args?.[0] &&
+                    f2.args?.[1] &&
+                    !formulasEqual(f1, f2)) {
+                    // Search for a disjunction P|R in known formulas
+                    const p = f1.args[0];
+                    const q = f1.args[1];
+                    const r = f2.args[0];
+                    const s = f2.args[1];
+                    const disjHash = formulaHash({ kind: 'or', args: [p, r] });
+                    const disjHashRev = formulaHash({ kind: 'or', args: [r, p] });
+                    if (state.known.has(disjHash) || state.known.has(disjHashRev)) {
+                        const qs = { kind: 'or', args: [q, s] };
+                        const disjFormula = state.known.get(disjHash) ?? state.known.get(disjHashRev);
+                        if (!disjFormula)
+                            continue;
+                        changed =
+                            addDerivedFormula(state, qs, 'Dilema Constructivo', [
+                                findStep(state.steps, f1),
+                                findStep(state.steps, f2),
+                                findStep(state.steps, disjFormula),
+                            ]) || changed;
+                    }
+                }
+                // Resolución: P|Q, !P|R derivar Q|R
+                if (f1.kind === 'or' &&
+                    f1.args?.[0] &&
+                    f1.args?.[1] &&
+                    f2.kind === 'or' &&
+                    f2.args?.[0] &&
+                    f2.args?.[1]) {
+                    if (f2.args[0].kind === 'not' &&
+                        f2.args[0].args?.[0] &&
+                        formulasEqual(f1.args[0], f2.args[0].args[0])) {
+                        const qr = { kind: 'or', args: [f1.args[1], f2.args[1]] };
+                        changed =
+                            addDerivedFormula(state, qr, 'Resolucion', [
+                                findStep(state.steps, f1),
+                                findStep(state.steps, f2),
+                            ]) || changed;
+                    }
+                }
+                // Explosión: de A y !A, derivar la meta solicitada
+                if (goal &&
+                    ((f1.kind === 'not' && f1.args?.[0] && formulasEqual(f1.args[0], f2)) ||
+                        (f2.kind === 'not' && f2.args?.[0] && formulasEqual(f2.args[0], f1)))) {
+                    changed =
+                        addDerivedFormula(state, goal, 'Explosion', [
+                            findStep(state.steps, f1),
+                            findStep(state.steps, f2),
+                        ]) || changed;
+                }
+            }
+            // Eliminación de contradicción: de false (⊥), derivar cualquier meta
+            if (f1.kind === 'false' && !formulasEqual(f1, goal)) {
+                changed =
+                    addDerivedFormula(state, goal, 'Explosion', [findStep(state.steps, f1)]) || changed;
+            }
+            // Conjunction Elimination: de A & B, derivar A y B
+            if (f1.kind === 'and' && f1.args) {
+                for (const sub of f1.args) {
+                    changed =
+                        addDerivedFormula(state, sub, 'Eliminacion de conjuncion', [
+                            findStep(state.steps, f1),
+                        ]) || changed;
+                }
+            }
+            const commutative = getCommutativeVariant(f1);
+            if (commutative && isRelevantToGoal(commutative, goal)) {
+                changed =
+                    addDerivedFormula(state, commutative, 'Conmutatividad', [findStep(state.steps, f1)]) ||
+                        changed;
+            }
+            for (const associative of getAssociativeVariants(f1)) {
+                if (isRelevantToGoal(associative, goal)) {
+                    changed =
+                        addDerivedFormula(state, associative, 'Asociatividad', [findStep(state.steps, f1)]) ||
+                            changed;
+                }
+            }
+            if ((f1.kind === 'and' || f1.kind === 'or') &&
+                f1.args?.[0] &&
+                f1.args?.[1] &&
+                formulasEqual(f1.args[0], f1.args[1])) {
+                changed =
+                    addDerivedFormula(state, f1.args[0], 'Idempotencia', [findStep(state.steps, f1)]) ||
+                        changed;
+            }
+            const absorbed = getAbsorptionResult(f1);
+            if (absorbed) {
+                changed =
+                    addDerivedFormula(state, absorbed, 'Absorcion', [findStep(state.steps, f1)]) || changed;
+            }
+            // Disjunction Introduction: de A, derivar A | B
+            // Relaxed: also allow intermediate disjunctions that are relevant to goal
+            if (goal.kind === 'or' && goal.args?.[0] && goal.args?.[1]) {
+                if (formulasEqual(f1, goal.args[0]) || formulasEqual(f1, goal.args[1])) {
+                    changed =
+                        addDerivedFormula(state, goal, 'Introduccion de disyuncion', [
+                            findStep(state.steps, f1),
+                        ]) || changed;
+                }
+            }
+            // Also check if f1 can form a disjunction relevant to some intermediate goal
+            if (goal.kind !== 'or') {
+                // If the goal is e.g. (A|B) -> C, and we have A, generate A|B as intermediate
+                const checkDisjGoals = (g) => {
+                    if (g.kind === 'or' && g.args?.[0] && g.args?.[1]) {
+                        if (formulasEqual(f1, g.args[0]) || formulasEqual(f1, g.args[1])) {
+                            const disj = { kind: 'or', args: [g.args[0], g.args[1]] };
+                            changed =
+                                addDerivedFormula(state, disj, 'Introduccion de disyuncion', [
+                                    findStep(state.steps, f1),
+                                ]) || changed;
+                        }
+                    }
+                    g.args?.forEach(checkDisjGoals);
+                };
+                checkDisjGoals(goal);
+            }
+            // Double Negation Elimination: de !!A, derivar A
+            if (f1.kind === 'not' && f1.args?.[0]?.kind === 'not' && f1.args[0].args?.[0]) {
+                const inner = f1.args[0].args[0];
+                changed =
+                    addDerivedFormula(state, inner, 'Doble negacion', [findStep(state.steps, f1)]) || changed;
+            }
+            // Double Negation Introduction: de A, derivar !!A solo si es la meta
+            const doubleNegation = { kind: 'not', args: [{ kind: 'not', args: [f1] }] };
+            if (formulasEqual(doubleNegation, goal)) {
+                changed =
+                    addDerivedFormula(state, doubleNegation, 'Introduccion de doble negacion', [
+                        findStep(state.steps, f1),
+                    ]) || changed;
+            }
+            // Weakening (Debilitamiento): si la meta es A -> B y ya conocemos B,
+            // entonces A -> B es válida (B ⊢ A -> B en lógica clásica).
+            if (goal.kind === 'implies' &&
+                goal.args?.[0] &&
+                goal.args?.[1] &&
+                formulasEqual(goal.args[1], f1)) {
+                changed =
+                    addDerivedFormula(state, goal, 'Debilitamiento (B ⊢ A → B)', [
+                        findStep(state.steps, f1),
+                    ]) || changed;
+            }
+            // Implicación material (→ a ∨): de A->B, derivar !A|B
+            if (f1.kind === 'implies' && f1.args?.[0] && f1.args?.[1]) {
+                const matImpl = {
+                    kind: 'or',
+                    args: [{ kind: 'not', args: [f1.args[0]] }, f1.args[1]],
+                };
+                if (isRelevantToGoal(matImpl, goal)) {
+                    changed =
+                        addDerivedFormula(state, matImpl, 'Implicacion material (→ a ∨)', [
+                            findStep(state.steps, f1),
+                        ]) || changed;
+                }
+            }
+            // Implicación material inversa (∨ a →): de !A|B, derivar A->B
+            if (f1.kind === 'or' &&
+                f1.args?.[0]?.kind === 'not' &&
+                f1.args[0].args?.[0] &&
+                f1.args?.[1]) {
+                const impl = {
+                    kind: 'implies',
+                    args: [f1.args[0].args[0], f1.args[1]],
+                };
+                if (isRelevantToGoal(impl, goal)) {
+                    changed =
+                        addDerivedFormula(state, impl, 'Implicacion material (∨ a →)', [
+                            findStep(state.steps, f1),
+                        ]) || changed;
+                }
+            }
+            // Contraposition: de A->B, derivar !B->!A
+            // Restringir a fórmulas con profundidad de negación baja para evitar
+            // cadenas infinitas de contrapositivas (!!A→!!B → !!!B→!!!A → ...)
+            if (f1.kind === 'implies' &&
+                f1.args?.[0] &&
+                f1.args?.[1] &&
+                maxNegationDepth(f1) < 2 &&
+                state.known.size < MAX_KNOWN) {
+                const contra = {
+                    kind: 'implies',
+                    args: [
+                        { kind: 'not', args: [f1.args[1]] },
+                        { kind: 'not', args: [f1.args[0]] },
+                    ],
+                };
+                changed =
+                    addDerivedFormula(state, contra, 'Contraposicion', [findStep(state.steps, f1)]) ||
+                        changed;
+            }
+            // Biconditional Elimination: de A<->B, derivar A->B y B->A
+            if (f1.kind === 'biconditional' && f1.args?.[0] && f1.args?.[1]) {
+                const ab = { kind: 'implies', args: [f1.args[0], f1.args[1]] };
+                const ba = { kind: 'implies', args: [f1.args[1], f1.args[0]] };
+                for (const impl of [ab, ba]) {
+                    changed =
+                        addDerivedFormula(state, impl, 'Eliminacion de bicondicional', [
+                            findStep(state.steps, f1),
+                        ]) || changed;
+                }
+            }
+            // Absorción: P->Q ⊢ P->(P&Q) — SOLO si resultado es relevante al goal
+            if (f1.kind === 'implies' && f1.args?.[0] && f1.args?.[1]) {
+                const abs = {
+                    kind: 'implies',
+                    args: [f1.args[0], { kind: 'and', args: [f1.args[0], f1.args[1]] }],
+                };
+                if (isRelevantToGoal(abs, goal)) {
+                    changed =
+                        addDerivedFormula(state, abs, 'Absorcion', [findStep(state.steps, f1)]) || changed;
+                }
+            }
+            // Exportación: (P&Q)->R ⊢ P->(Q->R) — SOLO si resultado es relevante al goal
+            if (f1.kind === 'implies' &&
+                f1.args?.[0]?.kind === 'and' &&
+                f1.args[0].args?.[0] &&
+                f1.args[0].args?.[1] &&
+                f1.args?.[1]) {
+                const exp = {
+                    kind: 'implies',
+                    args: [f1.args[0].args[0], { kind: 'implies', args: [f1.args[0].args[1], f1.args[1]] }],
+                };
+                if (isRelevantToGoal(exp, goal)) {
+                    changed =
+                        addDerivedFormula(state, exp, 'Exportacion', [findStep(state.steps, f1)]) || changed;
+                }
+            }
+            // Importación: P->(Q->R) ⊢ (P&Q)->R — SOLO si resultado es relevante al goal
+            if (f1.kind === 'implies' &&
+                f1.args?.[0] &&
+                f1.args?.[1]?.kind === 'implies' &&
+                f1.args[1].args?.[0] &&
+                f1.args[1].args?.[1]) {
+                const imp = {
+                    kind: 'implies',
+                    args: [{ kind: 'and', args: [f1.args[0], f1.args[1].args[0]] }, f1.args[1].args[1]],
+                };
+                if (isRelevantToGoal(imp, goal)) {
+                    changed =
+                        addDerivedFormula(state, imp, 'Importacion', [findStep(state.steps, f1)]) || changed;
+                }
+            }
+            // De Morgan 1: !(P&Q) ⊢ !P|!Q
+            if (f1.kind === 'not' &&
+                f1.args?.[0]?.kind === 'and' &&
+                f1.args[0].args?.[0] &&
+                f1.args[0].args?.[1]) {
+                const dm1 = {
+                    kind: 'or',
+                    args: [
+                        { kind: 'not', args: [f1.args[0].args[0]] },
+                        { kind: 'not', args: [f1.args[0].args[1]] },
+                    ],
+                };
+                changed =
+                    addDerivedFormula(state, dm1, 'De Morgan (AND)', [findStep(state.steps, f1)]) || changed;
+            }
+            // De Morgan 2: !(P|Q) ⊢ !P&!Q
+            if (f1.kind === 'not' &&
+                f1.args?.[0]?.kind === 'or' &&
+                f1.args[0].args?.[0] &&
+                f1.args[0].args?.[1]) {
+                const dm2 = {
+                    kind: 'and',
+                    args: [
+                        { kind: 'not', args: [f1.args[0].args[0]] },
+                        { kind: 'not', args: [f1.args[0].args[1]] },
+                    ],
+                };
+                changed =
+                    addDerivedFormula(state, dm2, 'De Morgan (OR)', [findStep(state.steps, f1)]) || changed;
+            }
+            // Distribución 1: P & (Q | R) ⊢ (P & Q) | (P & R)
+            if (f1.kind === 'and' &&
+                f1.args?.[0] &&
+                f1.args?.[1]?.kind === 'or' &&
+                f1.args[1].args?.[0] &&
+                f1.args[1].args?.[1]) {
+                const dist = {
+                    kind: 'or',
+                    args: [
+                        { kind: 'and', args: [f1.args[0], f1.args[1].args[0]] },
+                        { kind: 'and', args: [f1.args[0], f1.args[1].args[1]] },
+                    ],
+                };
+                changed =
+                    addDerivedFormula(state, dist, 'Distribucion (AND sobre OR)', [
+                        findStep(state.steps, f1),
+                    ]) || changed;
+            }
+            // Distribución 1b: (Q | R) & P ⊢ (Q & P) | (R & P)
+            if (f1.kind === 'and' &&
+                f1.args?.[0]?.kind === 'or' &&
+                f1.args[0].args?.[0] &&
+                f1.args[0].args?.[1] &&
+                f1.args?.[1]) {
+                const dist = {
+                    kind: 'or',
+                    args: [
+                        { kind: 'and', args: [f1.args[0].args[0], f1.args[1]] },
+                        { kind: 'and', args: [f1.args[0].args[1], f1.args[1]] },
+                    ],
+                };
+                changed =
+                    addDerivedFormula(state, dist, 'Distribucion (AND sobre OR)', [
+                        findStep(state.steps, f1),
+                    ]) || changed;
+            }
+            // Distribución 2: P | (Q & R) ⊢ (P | Q) & (P | R)
+            if (f1.kind === 'or' &&
+                f1.args?.[0] &&
+                f1.args?.[1]?.kind === 'and' &&
+                f1.args[1].args?.[0] &&
+                f1.args[1].args?.[1]) {
+                const dist = {
+                    kind: 'and',
+                    args: [
+                        { kind: 'or', args: [f1.args[0], f1.args[1].args[0]] },
+                        { kind: 'or', args: [f1.args[0], f1.args[1].args[1]] },
+                    ],
+                };
+                if (isRelevantToGoal(dist, goal)) {
+                    changed =
+                        addDerivedFormula(state, dist, 'Distribucion (OR sobre AND)', [
+                            findStep(state.steps, f1),
+                        ]) || changed;
+                }
+            }
+            // Distribución 2b: (Q & R) | P ⊢ (Q | P) & (R | P)
+            if (f1.kind === 'or' &&
+                f1.args?.[0]?.kind === 'and' &&
+                f1.args[0].args?.[0] &&
+                f1.args[0].args?.[1] &&
+                f1.args?.[1]) {
+                const dist = {
+                    kind: 'and',
+                    args: [
+                        { kind: 'or', args: [f1.args[0].args[0], f1.args[1]] },
+                        { kind: 'or', args: [f1.args[0].args[1], f1.args[1]] },
+                    ],
+                };
+                if (isRelevantToGoal(dist, goal)) {
+                    changed =
+                        addDerivedFormula(state, dist, 'Distribucion (OR sobre AND)', [
+                            findStep(state.steps, f1),
+                        ]) || changed;
+                }
+            }
+            // RAA (Reductio ad Absurdum) #29:
+            // Si tenemos P→Q y P→¬Q (o ¬Q→P y Q→P), derivar ¬P
+            if (f1.kind === 'implies' && f1.args?.[0] && f1.args?.[1]) {
+                for (let j = 0; j < currentFormulas.length; j++) {
+                    if (i < prevProcessedIndex && j < prevProcessedIndex)
+                        continue;
+                    const f2 = currentFormulas[j];
+                    if (f2.kind === 'implies' &&
+                        f2.args?.[0] &&
+                        f2.args?.[1] &&
+                        formulasEqual(f1.args[0], f2.args[0])) {
+                        // P→Q and P→¬Q => ¬P
+                        if (f2.args[1].kind === 'not' &&
+                            f2.args[1].args?.[0] &&
+                            formulasEqual(f1.args[1], f2.args[1].args[0])) {
+                            const negP = { kind: 'not', args: [f1.args[0]] };
+                            changed =
+                                addDerivedFormula(state, negP, 'Reduccion al Absurdo (RAA)', [
+                                    findStep(state.steps, f1),
+                                    findStep(state.steps, f2),
+                                ]) || changed;
+                        }
+                    }
+                }
+            }
+            // Prueba Condicional (#30):
+            // Si el goal es A→B y tenemos A entre las premisas/conocidas,
+            // y derivamos B, entonces obtenemos A→B
+            if (goal.kind === 'implies' &&
+                goal.args?.[0] &&
+                goal.args?.[1] &&
+                formulasEqual(f1, goal.args[1])) {
+                // We have B derived, and goal is A→B
+                if (state.known.has(formulaHash(goal.args[0]))) {
+                    // We also have A, so A→B via Prueba Condicional
+                    changed =
+                        addDerivedFormula(state, goal, 'Prueba Condicional', [
+                            findStep(state.steps, goal.args[0]),
+                            findStep(state.steps, f1),
+                        ]) || changed;
+                }
+            }
+        }
+    }
+    if (state.known.has(formulaHash(goal))) {
+        // Filtrar solo pasos relevantes para la derivación
+        const relevantSteps = traceBack(state.steps, goal);
+        return buildProof(goal, relevantSteps, premiseNames, theory, 'natural_deduction', undefined, buildDerivationMetadata(state, relevantSteps));
+    }
+    // --- Sub-derivaciones recursivas (antes del fallback semántico) ---
+    const MAX_SUB_DEPTH = 3;
+    // Prueba Condicional real (→-Introducción / Deduction Theorem):
+    // Para derivar A→B, asumimos A como premisa temporal y derivamos B.
+    if (depth < MAX_SUB_DEPTH && goal.kind === 'implies' && goal.args?.[0] && goal.args?.[1]) {
+        const assumption = goal.args[0];
+        const subGoal = goal.args[1];
+        // Create a temporary theory with the assumption added
+        const tempTheory = {
+            profile: theory.profile,
+            axioms: new Map(theory.axioms),
+            theorems: new Map(theory.theorems),
+            claims: theory.claims,
+            judgments: theory.judgments,
+        };
+        const assumptionName = `__assumption_${depth}_${formulaHash(assumption)}`;
+        tempTheory.axioms.set(assumptionName, assumption);
+        const subPremises = [...premiseNames, assumptionName];
+        const subProof = tryDerive(subGoal, tempTheory, subPremises, depth + 1);
+        if (subProof && subProof.status === 'complete') {
+            // Check the sub-proof doesn't rely solely on semantic fallback
+            const isSyntactic = subProof.steps.every((s) => s.source !== 'semantic');
+            if (isSyntactic) {
+                // Build the main proof: premises + sub-derivation steps + conditional proof conclusion
+                const mainSteps = [];
+                let stepNum = 0;
+                // Copy premise steps from current state
+                for (const s of state.steps) {
+                    if (s.source === 'premise') {
+                        stepNum++;
+                        mainSteps.push({ ...s, stepNumber: stepNum, premises: [] });
+                    }
+                }
+                // Add assumption step
+                stepNum++;
+                const assumptionStepNum = stepNum;
+                mainSteps.push({
+                    stepNumber: stepNum,
+                    formula: assumption,
+                    justification: 'Supuesto (para prueba condicional)',
+                    premises: [],
+                    source: 'assumption',
+                });
+                // Add sub-derivation steps (renumber, adjusting premise references)
+                const subStepMap = new Map();
+                for (const s of subProof.steps) {
+                    if (s.source === 'premise' && formulasEqual(s.formula, assumption)) {
+                        subStepMap.set(s.stepNumber, assumptionStepNum);
+                        continue;
+                    }
+                    if (s.source === 'premise') {
+                        // Find existing premise step in main
+                        const existing = mainSteps.find((ms) => ms.source === 'premise' && formulasEqual(ms.formula, s.formula));
+                        if (existing) {
+                            subStepMap.set(s.stepNumber, existing.stepNumber);
+                            continue;
+                        }
+                    }
+                    stepNum++;
+                    subStepMap.set(s.stepNumber, stepNum);
+                    mainSteps.push({
+                        stepNumber: stepNum,
+                        formula: s.formula,
+                        justification: s.justification,
+                        premises: s.premises.map((p) => subStepMap.get(p) || p),
+                        source: s.source,
+                    });
+                }
+                // Add final conditional proof step
+                stepNum++;
+                const subGoalStepNum = subStepMap.get(subProof.steps[subProof.steps.length - 1]?.stepNumber ?? 0) ?? stepNum - 1;
+                mainSteps.push({
+                    stepNumber: stepNum,
+                    formula: goal,
+                    justification: 'Prueba Condicional (Teorema de Deduccion)',
+                    premises: [assumptionStepNum, subGoalStepNum],
+                    subproofs: [subProof],
+                    source: 'rule',
+                });
+                return buildProof(goal, mainSteps, premiseNames, theory, 'natural_deduction', [subProof], buildCompositeDerivationMetadata(state, mainSteps, [subProof]));
+            }
+        }
+    }
+    // Prueba por Casos (∨-Eliminación / Disjunction Elimination):
+    // Si tenemos A|B y queremos derivar C, asumimos A→C y B→C por separado.
+    if (depth < MAX_SUB_DEPTH) {
+        const disjunctions = state.formulas.filter((f) => f.kind === 'or' && f.args?.[0] && f.args?.[1]);
+        for (const disj of disjunctions) {
+            const left = disj.args?.[0];
+            const right = disj.args?.[1];
+            if (!left || !right)
+                continue;
+            // Try to derive goal assuming left
+            const tempTheoryL = {
+                profile: theory.profile,
+                axioms: new Map(theory.axioms),
+                theorems: new Map(theory.theorems),
+                claims: theory.claims,
+                judgments: theory.judgments,
+            };
+            const leftName = `__case_left_${depth}_${formulaHash(left)}`;
+            tempTheoryL.axioms.set(leftName, left);
+            const subPremisesL = [...premiseNames, leftName];
+            const subProofL = tryDerive(goal, tempTheoryL, subPremisesL, depth + 1);
+            if (!subProofL || subProofL.status !== 'complete')
+                continue;
+            const isSyntacticL = subProofL.steps.every((s) => s.source !== 'semantic');
+            if (!isSyntacticL)
+                continue;
+            // Try to derive goal assuming right
+            const tempTheoryR = {
+                profile: theory.profile,
+                axioms: new Map(theory.axioms),
+                theorems: new Map(theory.theorems),
+                claims: theory.claims,
+                judgments: theory.judgments,
+            };
+            const rightName = `__case_right_${depth}_${formulaHash(right)}`;
+            tempTheoryR.axioms.set(rightName, right);
+            const subPremisesR = [...premiseNames, rightName];
+            const subProofR = tryDerive(goal, tempTheoryR, subPremisesR, depth + 1);
+            if (!subProofR || subProofR.status !== 'complete')
+                continue;
+            const isSyntacticR = subProofR.steps.every((s) => s.source !== 'semantic');
+            if (!isSyntacticR)
+                continue;
+            // Both cases succeed — build proof by cases
+            const mainSteps = [];
+            let stepNum = 0;
+            // Copy premise steps
+            for (const s of state.steps) {
+                if (s.source === 'premise') {
+                    stepNum++;
+                    mainSteps.push({ ...s, stepNumber: stepNum, premises: [] });
+                }
+            }
+            const disjStepNum = mainSteps.find((ms) => formulasEqual(ms.formula, disj))?.stepNumber ?? 0;
+            // Left case sub-derivation
+            stepNum++;
+            const leftAssumptionStep = stepNum;
+            mainSteps.push({
+                stepNumber: stepNum,
+                formula: left,
+                justification: 'Supuesto (caso izquierdo)',
+                premises: [],
+                source: 'assumption',
+            });
+            const leftStepMap = new Map();
+            for (const s of subProofL.steps) {
+                if (s.source === 'premise' && formulasEqual(s.formula, left)) {
+                    leftStepMap.set(s.stepNumber, leftAssumptionStep);
+                    continue;
+                }
+                if (s.source === 'premise') {
+                    const existing = mainSteps.find((ms) => ms.source === 'premise' && formulasEqual(ms.formula, s.formula));
+                    if (existing) {
+                        leftStepMap.set(s.stepNumber, existing.stepNumber);
+                        continue;
+                    }
+                }
+                stepNum++;
+                leftStepMap.set(s.stepNumber, stepNum);
+                mainSteps.push({
+                    stepNumber: stepNum,
+                    formula: s.formula,
+                    justification: s.justification,
+                    premises: s.premises.map((p) => leftStepMap.get(p) || p),
+                    source: s.source,
+                });
+            }
+            const leftGoalStep = leftStepMap.get(subProofL.steps[subProofL.steps.length - 1]?.stepNumber ?? 0) ?? stepNum;
+            // Right case sub-derivation
+            stepNum++;
+            const rightAssumptionStep = stepNum;
+            mainSteps.push({
+                stepNumber: stepNum,
+                formula: right,
+                justification: 'Supuesto (caso derecho)',
+                premises: [],
+                source: 'assumption',
+            });
+            const rightStepMap = new Map();
+            for (const s of subProofR.steps) {
+                if (s.source === 'premise' && formulasEqual(s.formula, right)) {
+                    rightStepMap.set(s.stepNumber, rightAssumptionStep);
+                    continue;
+                }
+                if (s.source === 'premise') {
+                    const existing = mainSteps.find((ms) => ms.source === 'premise' && formulasEqual(ms.formula, s.formula));
+                    if (existing) {
+                        rightStepMap.set(s.stepNumber, existing.stepNumber);
+                        continue;
+                    }
+                }
+                stepNum++;
+                rightStepMap.set(s.stepNumber, stepNum);
+                mainSteps.push({
+                    stepNumber: stepNum,
+                    formula: s.formula,
+                    justification: s.justification,
+                    premises: s.premises.map((p) => rightStepMap.get(p) || p),
+                    source: s.source,
+                });
+            }
+            const rightGoalStep = rightStepMap.get(subProofR.steps[subProofR.steps.length - 1]?.stepNumber ?? 0) ?? stepNum;
+            // Final disjunction elimination step
+            stepNum++;
+            mainSteps.push({
+                stepNumber: stepNum,
+                formula: goal,
+                justification: 'Eliminacion de disyuncion (prueba por casos)',
+                premises: [disjStepNum, leftGoalStep, rightGoalStep],
+                subproofs: [subProofL, subProofR],
+                source: 'rule',
+            });
+            return buildProof(goal, mainSteps, premiseNames, theory, 'natural_deduction', [subProofL, subProofR], buildCompositeDerivationMetadata(state, mainSteps, [subProofL, subProofR]));
+        }
+    }
+    // Backchaining dirigido por meta: si tenemos A → objetivo,
+    // intentamos derivar A para cerrar con Modus Ponens sin esperar a que aparezca espontáneamente.
+    if (depth < MAX_SUB_DEPTH) {
+        const candidateImplications = state.formulas.filter((formula) => formula.kind === 'implies' &&
+            !!formula.args?.[0] &&
+            !!formula.args?.[1] &&
+            formulasEqual(formula.args[1], goal));
+        for (const implication of candidateImplications) {
+            const antecedent = implication.args?.[0];
+            if (!antecedent || formulasEqual(antecedent, goal))
+                continue;
+            const antecedentProof = tryDerive(antecedent, theory, premiseNames, depth + 1);
+            if (!antecedentProof || antecedentProof.status !== 'complete')
+                continue;
+            const antecedentIsSyntactic = antecedentProof.steps.every((step) => step.source !== 'semantic');
+            if (!antecedentIsSyntactic)
+                continue;
+            const implicationProof = buildKnownDerivationProof(state, implication, premiseNames, theory);
+            const mainSteps = buildMergedGoalProof(state.steps, [implicationProof, antecedentProof], goal, 'Modus Ponens');
+            return buildProof(goal, mainSteps, premiseNames, theory, 'natural_deduction', [implicationProof, antecedentProof], buildCompositeDerivationMetadata(state, mainSteps, [implicationProof, antecedentProof]));
+        }
+    }
+    // Backchaining dirigido por meta para Modus Tollens:
+    // Si la meta es ¬A y conocemos A → B, intentamos derivar ¬B.
+    // Si la meta es ¬A y conocemos A → ¬B, intentamos derivar B.
+    if (depth < MAX_SUB_DEPTH && goal.kind === 'not' && goal.args?.[0]) {
+        const negatedAntecedent = goal.args[0];
+        const candidateImplications = state.formulas.filter((formula) => formula.kind === 'implies' &&
+            !!formula.args?.[0] &&
+            !!formula.args?.[1] &&
+            formulasEqual(formula.args[0], negatedAntecedent));
+        for (const implication of candidateImplications) {
+            const consequent = implication.args?.[1];
+            if (!consequent)
+                continue;
+            const counterGoal = consequent.kind === 'not' && consequent.args?.[0]
+                ? consequent.args[0]
+                : { kind: 'not', args: [consequent] };
+            if (formulasEqual(counterGoal, goal) || formulasEqual(counterGoal, negatedAntecedent)) {
+                continue;
+            }
+            const counterProof = tryDerive(counterGoal, theory, premiseNames, depth + 1);
+            if (!counterProof || counterProof.status !== 'complete')
+                continue;
+            const counterIsSyntactic = counterProof.steps.every((step) => step.source !== 'semantic');
+            if (!counterIsSyntactic)
+                continue;
+            const implicationProof = buildKnownDerivationProof(state, implication, premiseNames, theory);
+            const mainSteps = buildMergedGoalProof(state.steps, [implicationProof, counterProof], goal, 'Modus Tollens');
+            return buildProof(goal, mainSteps, premiseNames, theory, 'natural_deduction', [implicationProof, counterProof], buildCompositeDerivationMetadata(state, mainSteps, [implicationProof, counterProof]));
+        }
+    }
+    // Meta conjuntiva (∧-Introducción dirigida por meta): derivar ambos componentes por separado.
+    if (depth < MAX_SUB_DEPTH && goal.kind === 'and' && goal.args?.[0] && goal.args?.[1]) {
+        const leftGoal = goal.args[0];
+        const rightGoal = goal.args[1];
+        const leftProof = tryDerive(leftGoal, theory, premiseNames, depth + 1);
+        const rightProof = tryDerive(rightGoal, theory, premiseNames, depth + 1);
+        if (leftProof &&
+            rightProof &&
+            leftProof.status === 'complete' &&
+            rightProof.status === 'complete') {
+            const leftSyntactic = leftProof.steps.every((s) => s.source !== 'semantic');
+            const rightSyntactic = rightProof.steps.every((s) => s.source !== 'semantic');
+            if (leftSyntactic && rightSyntactic) {
+                const mainSteps = buildMergedGoalProof(state.steps, [leftProof, rightProof], goal, 'Introduccion de conjuncion');
+                return buildProof(goal, mainSteps, premiseNames, theory, 'natural_deduction', [leftProof, rightProof], buildCompositeDerivationMetadata(state, mainSteps, [leftProof, rightProof]));
+            }
+        }
+    }
+    // Meta bicondicional (↔-Introducción dirigida por meta): demostrar ambos sentidos.
+    if (depth < MAX_SUB_DEPTH && goal.kind === 'biconditional' && goal.args?.[0] && goal.args?.[1]) {
+        const leftToRight = { kind: 'implies', args: [goal.args[0], goal.args[1]] };
+        const rightToLeft = { kind: 'implies', args: [goal.args[1], goal.args[0]] };
+        const leftProof = tryDerive(leftToRight, theory, premiseNames, depth + 1);
+        const rightProof = tryDerive(rightToLeft, theory, premiseNames, depth + 1);
+        if (leftProof &&
+            rightProof &&
+            leftProof.status === 'complete' &&
+            rightProof.status === 'complete') {
+            const leftSyntactic = leftProof.steps.every((s) => s.source !== 'semantic');
+            const rightSyntactic = rightProof.steps.every((s) => s.source !== 'semantic');
+            if (leftSyntactic && rightSyntactic) {
+                const mainSteps = buildMergedGoalProof(state.steps, [leftProof, rightProof], goal, 'Introduccion de bicondicional');
+                return buildProof(goal, mainSteps, premiseNames, theory, 'natural_deduction', [leftProof, rightProof], buildCompositeDerivationMetadata(state, mainSteps, [leftProof, rightProof]));
+            }
+        }
+    }
+    // Introducción de negación (¬-Introducción): para derivar ¬A,
+    // asumimos A y derivamos contradicción explícita (false / ⊥).
+    if (depth < MAX_SUB_DEPTH && goal.kind === 'not' && goal.args?.[0]) {
+        const assumption = goal.args[0];
+        const contradiction = { kind: 'false' };
+        const tempTheory = {
+            profile: theory.profile,
+            axioms: new Map(theory.axioms),
+            theorems: new Map(theory.theorems),
+            claims: theory.claims,
+            judgments: theory.judgments,
+        };
+        const assumptionName = `__neg_assumption_${depth}_${formulaHash(assumption)}`;
+        tempTheory.axioms.set(assumptionName, assumption);
+        const subPremises = [...premiseNames, assumptionName];
+        const subProof = tryDerive(contradiction, tempTheory, subPremises, depth + 1);
+        if (subProof && subProof.status === 'complete') {
+            const isSyntactic = subProof.steps.every((s) => s.source !== 'semantic');
+            if (isSyntactic) {
+                const mainSteps = buildSingleAssumptionProof(state.steps, assumption, 'Supuesto (para negacion)', subProof, goal, 'Introduccion de negacion');
+                return buildProof(goal, mainSteps, premiseNames, theory, 'natural_deduction', [subProof], buildCompositeDerivationMetadata(state, mainSteps, [subProof]));
+            }
+        }
+    }
+    // RAA genérica: para derivar A en lógica clásica,
+    // asumimos ¬A y buscamos contradicción explícita.
+    if (depth < MAX_SUB_DEPTH && goal.kind !== 'not' && goal.kind !== 'false') {
+        const assumption = { kind: 'not', args: [goal] };
+        const contradiction = { kind: 'false' };
+        const tempTheory = {
+            profile: theory.profile,
+            axioms: new Map(theory.axioms),
+            theorems: new Map(theory.theorems),
+            claims: theory.claims,
+            judgments: theory.judgments,
+        };
+        const assumptionName = `__raa_assumption_${depth}_${formulaHash(assumption)}`;
+        tempTheory.axioms.set(assumptionName, assumption);
+        const subPremises = [...premiseNames, assumptionName];
+        const subProof = tryDerive(contradiction, tempTheory, subPremises, depth + 1);
+        if (subProof && subProof.status === 'complete') {
+            const isSyntactic = subProof.steps.every((s) => s.source !== 'semantic');
+            if (isSyntactic) {
+                const mainSteps = buildSingleAssumptionProof(state.steps, assumption, 'Supuesto (para RAA)', subProof, goal, 'RAA (Reduccion al Absurdo)');
+                return buildProof(goal, mainSteps, premiseNames, theory, 'natural_deduction', [subProof], buildCompositeDerivationMetadata(state, mainSteps, [subProof]));
+            }
+        }
+    }
+    // Fallback: verificar semánticamente
+    const allAxiomFormulas = premiseNames
+        .map((n) => theory.axioms.get(n) || theory.theorems.get(n))
+        .filter((f) => f !== undefined);
+    if (allAxiomFormulas.length > 0) {
+        const atoms = new Set();
+        for (const f of allAxiomFormulas)
+            collectAtoms(f).forEach((a) => atoms.add(a));
+        collectAtoms(goal).forEach((a) => atoms.add(a));
+        const atomList = Array.from(atoms).sort();
+        let semanticResult;
+        // 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
+            semanticResult = bvIsZero(bvAnd(premisesConj, bvNot(goalBits, allOnes)));
+        }
+        else if (allPure && atomList.length > 26) {
+            // DPLL fallback for >26 atoms
+            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);
+            semanticResult = !result.satisfiable;
+        }
+        else {
+            // Classic fallback
+            const valuations = generateValuations(atomList);
+            semanticResult = true;
+            for (const v of valuations) {
+                const premisesTrue = allAxiomFormulas.every((f) => evaluateClassical(f, v));
+                if (premisesTrue && !evaluateClassical(goal, v)) {
+                    semanticResult = false;
+                    break;
+                }
+            }
+        }
+        if (semanticResult) {
+            // Generate a synthetic final proof step so the user sees a complete derivation
+            // instead of just "derivado exitosamente" with no proof trace.
+            const goalHash = formulaHash(goal);
+            if (!state.known.has(goalHash)) {
+                const premiseStepNums = premiseNames
+                    .map((n) => {
+                    const f = theory.axioms.get(n) || theory.theorems.get(n);
+                    return f ? findStep(state.steps, f) : 0;
+                })
+                    .filter((n) => n > 0);
+                state.stepCount++;
+                state.steps.push({
+                    stepNumber: state.stepCount,
+                    formula: goal,
+                    justification: 'Verificacion semantica (todas las valuaciones satisfacen la consecuencia)',
+                    premises: premiseStepNums,
+                    source: 'semantic',
+                });
+                state.known.set(goalHash, goal);
+            }
+            const relevantSteps = traceBack(state.steps, goal);
+            return buildProof(goal, relevantSteps, premiseNames, theory, 'semantic', undefined, buildDerivationMetadata(state, relevantSteps, true));
+        }
+    }
+    return null;
+}
+function findStep(stateOrSteps, formula) {
+    const hash = formulaHash(formula);
+    if (!Array.isArray(stateOrSteps)) {
+        const cached = stateOrSteps.stepByHash.get(hash);
+        if (cached !== undefined)
+            return cached;
+    }
+    const steps = Array.isArray(stateOrSteps) ? stateOrSteps : stateOrSteps.steps;
+    for (const s of steps) {
+        if (formulaHash(s.formula) === hash)
+            return s.stepNumber;
+    }
+    return 0;
+}
+function traceBack(steps, goal) {
+    const goalHash = formulaHash(goal);
+    const needed = new Set();
+    const goalStep = steps.find((s) => formulaHash(s.formula) === goalHash);
+    if (!goalStep)
+        return steps;
+    function trace(stepNum) {
+        if (needed.has(stepNum))
+            return;
+        needed.add(stepNum);
+        const step = steps.find((s) => s.stepNumber === stepNum);
+        if (step) {
+            for (const p of step.premises) {
+                trace(p);
+            }
+        }
+    }
+    trace(goalStep.stepNumber);
+    const filtered = steps.filter((s) => needed.has(s.stepNumber));
+    // Compact renumbering: eliminate gaps in step numbers
+    const oldToNew = new Map();
+    filtered.forEach((s, i) => {
+        oldToNew.set(s.stepNumber, i + 1);
+    });
+    return filtered.map((s) => ({
+        ...s,
+        stepNumber: oldToNew.get(s.stepNumber) ?? s.stepNumber,
+        premises: s.premises.map((p) => oldToNew.get(p) ?? p),
+    }));
+}
+// --- Perfil Classical Propositional ---
+class ClassicalPropositional {
+    name = 'classical.propositional';
+    description = 'Logica clasica proposicional con tabla de verdad, validez, satisfacibilidad, derivacion y contramodelo';
+    checkWellFormed(formula) {
+        const diags = [];
+        function check(f) {
+            switch (f.kind) {
+                case 'atom':
+                    if (!f.name) {
+                        diags.push({ severity: 'error', message: 'Atomo sin nombre' });
+                    }
+                    break;
+                case 'not':
+                    if (!f.args || f.args.length !== 1) {
+                        diags.push({
+                            severity: 'error',
+                            message: 'Negacion requiere exactamente un argumento',
+                        });
+                    }
+                    else if (f.args[0]) {
+                        check(f.args[0]);
+                    }
+                    break;
+                case 'and':
+                case 'or':
+                case 'implies':
+                case 'biconditional':
+                    if (!f.args || f.args.length !== 2) {
+                        diags.push({
+                            severity: 'error',
+                            message: `${f.kind} requiere exactamente dos argumentos`,
+                        });
+                    }
+                    else {
+                        if (f.args[0])
+                            check(f.args[0]);
+                        if (f.args[1])
+                            check(f.args[1]);
+                    }
+                    break;
+                case 'forall':
+                case 'exists':
+                case 'predicate':
+                case 'equals':
+                case 'modal_necessity':
+                case 'modal_possibility':
+                    diags.push({
+                        severity: 'error',
+                        message: `'${f.kind}' no esta soportado en logica proposicional clasica`,
+                    });
+                    break;
+            }
+        }
+        check(formula);
+        return diags;
+    }
+    checkValid(formula) {
+        const wf = this.checkWellFormed(formula);
+        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 {
+            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,
+            };
+        }
+    }
+    checkSatisfiable(formula) {
+        const wf = this.checkWellFormed(formula);
+        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);
+            return {
+                status: 'satisfiable',
+                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,
+            };
+        }
+        else {
+            return {
+                status: 'unsatisfiable',
+                output: `${formulaToString(formula)} es INSATISFACIBLE (contradiccion)`,
+                truthTable: tt,
+                educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'satisfiable', sat: false }),
+                diagnostics: [],
+                formula,
+            };
+        }
+    }
+    prove(goal, theory, premises) {
+        const wf = this.checkWellFormed(goal);
+        if (wf.length > 0) {
+            return { status: 'error', diagnostics: wf, formula: goal };
+        }
+        const usingRestricted = premises !== undefined && premises.length > 0;
+        const premiseNames = usingRestricted
+            ? premises.filter((n) => theory.axioms.has(n) || theory.theorems.has(n))
+            : Array.from(theory.axioms.keys());
+        const diagnostics = [];
+        if (usingRestricted) {
+            for (const n of premises) {
+                if (!theory.axioms.has(n) && !theory.theorems.has(n)) {
+                    diagnostics.push({
+                        severity: 'warning',
+                        message: `Premisa '${n}' no encontrada en la teoría; será ignorada en prove`,
+                    });
+                }
+            }
+        }
+        const effectiveTheory = usingRestricted
+            ? {
+                profile: theory.profile,
+                axioms: new Map(premiseNames
+                    .filter((n) => theory.axioms.has(n))
+                    .map((n) => [n, theory.axioms.get(n)])),
+                theorems: new Map(premiseNames
+                    .filter((n) => theory.theorems.has(n))
+                    .map((n) => [n, theory.theorems.get(n)])),
+                claims: theory.claims,
+                judgments: theory.judgments,
+            }
+            : theory;
+        const proof = tryDerive(goal, effectiveTheory, premiseNames);
+        if (proof && proof.status === 'complete') {
+            const isSemantic = proof.method === 'semantic';
+            return {
+                status: 'provable',
+                output: isSemantic
+                    ? `${formulaToString(goal)} es DEMOSTRABLE desde la teoria (verificación semántica, sin derivación sintáctica)`
+                    : `${formulaToString(goal)} es DEMOSTRABLE desde la teoria`,
+                proof,
+                educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'prove', ok: true }),
+                diagnostics,
+                formula: goal,
+            };
+        }
+        // Semantic fallback: verify via SAT/truth-table whether goal follows from axioms
+        const allAxiomFormulas = premiseNames
+            .map((n) => effectiveTheory.axioms.get(n) || effectiveTheory.theorems.get(n))
+            .filter((f) => f !== undefined);
+        let semanticResult;
+        const atoms = new Set();
+        for (const f of allAxiomFormulas)
+            collectAtoms(f).forEach((a) => atoms.add(a));
+        collectAtoms(goal).forEach((a) => atoms.add(a));
+        const atomList = Array.from(atoms).sort();
+        if (allAxiomFormulas.length > 0) {
+            // With premises: check if premises entail goal
+            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);
+                let premisesConj = allOnes;
+                for (const pb of premiseBits)
+                    premisesConj = bvAnd(premisesConj, pb);
+                semanticResult = bvIsZero(bvAnd(premisesConj, bvNot(goalBits, allOnes)));
+            }
+            else if (allPure && atomList.length > 26) {
+                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] };
+                semanticResult = !(0, dpll_1.dpll)(check).satisfiable;
+            }
+            else {
+                const valuations = generateValuations(atomList);
+                semanticResult = true;
+                for (const v of valuations) {
+                    const premisesTrue = allAxiomFormulas.every((f) => evaluateClassical(f, v));
+                    if (premisesTrue && !evaluateClassical(goal, v)) {
+                        semanticResult = false;
+                        break;
+                    }
+                }
+            }
+        }
+        else {
+            // No premises: check if goal is a tautology
+            if (isPurePropositional(goal) && atomList.length <= 26) {
+                const { result, allOnes } = evaluateBitset(goal, atomList);
+                semanticResult = bvEquals(result, allOnes);
+            }
+            else if (isPurePropositional(goal) && atomList.length > 26) {
+                const negated = { kind: 'not', args: [goal] };
+                semanticResult = !(0, dpll_1.dpll)(negated).satisfiable;
+            }
+            else {
+                const valuations = generateValuations(atomList);
+                semanticResult = valuations.every((v) => evaluateClassical(goal, v));
+            }
+        }
+        if (semanticResult) {
+            const premiseSteps = [];
+            premiseNames.forEach((n, i) => {
+                const f = effectiveTheory.axioms.get(n) || effectiveTheory.theorems.get(n);
+                if (f) {
+                    premiseSteps.push({
+                        stepNumber: i + 1,
+                        formula: f,
+                        justification: `Premisa (${n})`,
+                        premises: [],
+                        source: 'premise',
+                    });
+                }
+            });
+            const semanticProofSteps = [
+                ...premiseSteps,
+                {
+                    stepNumber: premiseNames.length + 1,
+                    formula: goal,
+                    justification: 'Verificacion semantica (tautologia o consecuencia logica)',
+                    premises: premiseNames.map((_, i) => i + 1),
+                    source: 'semantic',
+                },
+            ];
+            const semanticProof = buildProof(goal, semanticProofSteps, premiseNames, effectiveTheory, 'semantic');
+            return {
+                status: 'provable',
+                output: `${formulaToString(goal)} es DEMOSTRABLE desde la teoria (verificación semántica, sin derivación sintáctica)`,
+                proof: semanticProof,
+                educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'prove', ok: true }),
+                diagnostics,
+                formula: goal,
+            };
+        }
+        // Ni derivación sintáctica ni consecuencia semántica: existe contramodelo.
+        // Esto sí es refutable en el sentido fuerte.
+        return {
+            status: 'refutable',
+            output: `${formulaToString(goal)} NO se sigue de la teoría (existe contramodelo en ${formulaToString(goal)})`,
+            educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'prove', ok: false }),
+            diagnostics,
+            formula: goal,
+        };
+    }
+    derive(goal, premises, theory) {
+        const wf = this.checkWellFormed(goal);
+        if (wf.length > 0) {
+            return { status: 'error', diagnostics: wf, formula: goal };
+        }
+        const proof = tryDerive(goal, theory, premises);
+        if (proof && proof.status === 'complete') {
+            // Build reasoning info
+            const rulesUsed = new Set();
+            for (const step of proof.steps) {
+                if (step.source !== 'premise') {
+                    rulesUsed.add(step.justification);
+                }
+            }
+            const reasoningType = rulesUsed.size > 0 ? Array.from(rulesUsed).join(', ') : 'Derivación directa';
+            const isSemantic = proof.method === 'semantic';
+            return {
+                status: 'provable',
+                output: isSemantic
+                    ? `${formulaToString(goal)} derivado (verificación semántica, sin derivación sintáctica)`
+                    : `${formulaToString(goal)} derivado exitosamente`,
+                proof,
+                reasoningType,
+                reasoningSchema: rulesUsed.has('Introduccion de negacion')
+                    ? '[φ] ⊢ ⊥, por lo tanto ¬φ'
+                    : rulesUsed.has('RAA (Reduccion al Absurdo)')
+                        ? '[¬φ] ⊢ ⊥, por lo tanto φ'
+                        : rulesUsed.has('Contradiccion')
+                            ? 'φ, ¬φ ⊢ ⊥'
+                            : rulesUsed.has('Explosion')
+                                ? '⊥ ⊢ ψ'
+                                : rulesUsed.has('Prueba Condicional (Teorema de Deduccion)')
+                                    ? '[φ] ⊢ ψ, por lo tanto φ → ψ'
+                                    : rulesUsed.has('Modus Ponens')
+                                        ? 'φ → ψ, φ ⊢ ψ'
+                                        : rulesUsed.has('Modus Tollens')
+                                            ? 'φ → ψ, ¬ψ ⊢ ¬φ'
+                                            : rulesUsed.has('Silogismo Hipotetico')
+                                                ? 'φ → ψ, ψ → χ ⊢ φ → χ'
+                                                : undefined,
+                educationalNote: (0, educational_notes_1.pickEducationalNote)({
+                    op: 'derive',
+                    ok: true,
+                    steps: proof.steps.length,
+                    rules: Array.from(rulesUsed),
+                }),
+                diagnostics: [],
+                formula: goal,
+            };
+        }
+        return {
+            status: 'unknown',
+            output: `No se pudo derivar ${formulaToString(goal)} desde las premisas dadas (sin refutación)`,
+            educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'derive', ok: false }),
+            diagnostics: [],
+            formula: goal,
+        };
+    }
+    countermodel(formula) {
+        const wf = this.checkWellFormed(formula);
+        if (wf.length > 0) {
+            return { status: 'error', diagnostics: wf, 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 (!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,
+                };
+            }
+        }
+        return {
+            status: 'valid',
+            output: `${formulaToString(formula)} es tautologia, no hay contramodelo`,
+            educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'countermodel', found: false }),
+            diagnostics: [],
+            formula,
+        };
+    }
+    explain(formula) {
+        if (!isPurePropositional(formula)) {
+            return {
+                status: 'error',
+                output: `explain solo esta disponible para formulas puramente proposicionales: ${(0, format_1.formulaToUnicode)(formula)}`,
+                diagnostics: [
+                    {
+                        severity: 'error',
+                        message: 'La formula incluye operadores no proposicionales; use un perfil con explain semantico especifico.',
+                    },
+                    ...this.checkWellFormed(formula),
+                ],
+                formula,
+            };
+        }
+        const wf = this.checkWellFormed(formula);
+        if (wf.length > 0) {
+            return { status: 'error', diagnostics: wf, formula };
+        }
+        const tt = this.truthTable(formula);
+        const tAnalysis = (0, formula_classifier_1.classifyFormula)(formula);
+        let explanation = `Fórmula: ${(0, format_1.formulaToUnicode)(formula)}\n`;
+        if (tAnalysis.formulaAnalysis.mainConnective) {
+            explanation += `Conectivo principal: ${tAnalysis.formulaAnalysis.mainConnective}\n`;
+        }
+        explanation += `Profundidad: ${tAnalysis.formulaAnalysis.depth}\n`;
+        explanation += `Complejidad: ${tAnalysis.formulaAnalysis.complexity} conectivos\n`;
+        explanation += `Átomos: { ${Array.from(collectAtoms(formula)).join(', ')} }\n`;
+        if (tAnalysis.formulaAnalysis.subFormulas.length > 0) {
+            explanation += `\nSub-fórmulas:\n`;
+            for (const sf of tAnalysis.formulaAnalysis.subFormulas) {
+                explanation += `  ├─ ${sf}\n`;
+            }
+        }
+        explanation += `\nFormas normales:\n`;
+        const nnf = toNNF(formula);
+        const cnf = toCNF(formula);
+        const dnf = toDNF(formula);
+        explanation += `  NNF: ${formulaToString(nnf)}\n`;
+        explanation += `  CNF: ${formulaToString(cnf)}\n`;
+        explanation += `  DNF: ${formulaToString(dnf)}\n`;
+        // #28: Cláusulas de resolución
+        const clauses = extractClauses(formula);
+        if (clauses.length > 0 && clauses.length <= 8) {
+            explanation += `\nCláusulas (resolución):\n`;
+            for (let i = 0; i < clauses.length; i++) {
+                explanation += `  C${i + 1}: {${clauses[i].join(', ')}}\n`;
+            }
+        }
+        // #24: Completitud funcional
+        const atomsList = Array.from(collectAtoms(formula));
+        const connectives = new Set();
+        const walkConn = (f) => {
+            if (f.kind !== 'atom')
+                connectives.add(f.kind);
+            f.args?.forEach(walkConn);
+        };
+        walkConn(formula);
+        const hasNeg = connectives.has('not');
+        const hasAnd = connectives.has('and');
+        const hasOr = connectives.has('or');
+        const hasImplies = connectives.has('implies');
+        const hasBicond = connectives.has('biconditional');
+        const hasNand = connectives.has('nand');
+        const hasNor = connectives.has('nor');
+        let isFunctionallyComplete = false;
+        let completenessNote = '';
+        if (hasNand || hasNor) {
+            isFunctionallyComplete = true;
+            completenessNote = hasNand
+                ? '{↑} (NAND solo — Sheffer stroke)'
+                : '{↓} (NOR solo — Peirce arrow)';
+        }
+        else if (hasNeg && (hasAnd || hasOr || hasImplies || hasBicond)) {
+            isFunctionallyComplete = true;
+            completenessNote = hasNeg && hasAnd ? '{¬, ∧}' : hasNeg && hasOr ? '{¬, ∨}' : '{¬, →}';
+        }
+        explanation += `\nCompletitud funcional: ${isFunctionallyComplete ? `✓ Usa conjunto completo: ${completenessNote}` : '✗ El conjunto de conectivos usado no es funcionalmente completo'}\n`;
+        // #26: Esquemas de dominancia/identidad
+        if (atomsList.length <= 2) {
+            explanation += `\nEsquemas algebraicos verificados:\n`;
+            explanation += `  ✓ P ∧ ⊤ ≡ P       (identidad conjuntiva)\n`;
+            explanation += `  ✓ P ∨ ⊥ ≡ P       (identidad disyuntiva)\n`;
+            explanation += `  ✓ P ∧ ⊥ ≡ ⊥       (dominancia conjuntiva)\n`;
+            explanation += `  ✓ P ∨ ⊤ ≡ ⊤       (dominancia disyuntiva)\n`;
+            explanation += `  ✓ P ∧ ¬P ≡ ⊥      (complemento)\n`;
+            explanation += `  ✓ P ∨ ¬P ≡ ⊤      (tercero excluido)\n`;
+        }
+        if (tAnalysis.formulaClassification) {
+            explanation += `\nClasificación semántica: Tautología\n`;
+            explanation += `Nombre conocido: ${tAnalysis.formulaClassification}\n`;
+        }
+        explanation += `\nTabla de verdad:\n`;
+        explanation += `  ${tt.totalCount} valuaciones, ${tt.satisfyingCount} verdaderas, ${tt.totalCount - tt.satisfyingCount} falsas\n`;
+        if (tt.isTautology)
+            explanation += `  → Tautología ✓\n`;
+        else if (tt.isContradiction)
+            explanation += `  → Contradicción ✗\n`;
+        else
+            explanation += `  → Contingente (satisfacible)\n`;
+        return {
+            status: tt.isTautology ? 'valid' : tt.isSatisfiable ? 'satisfiable' : 'unsatisfiable',
+            output: explanation,
+            truthTable: tt,
+            diagnostics: [],
+            formula,
+            formulaAnalysis: tAnalysis.formulaAnalysis,
+            formulaClassification: tAnalysis.formulaClassification,
+            normalForms: {
+                nnf: formulaToString(nnf),
+                cnf: formulaToString(cnf),
+                dnf: formulaToString(dnf),
+            },
+        };
+    }
+    truthTable(formula) {
+        const atoms = Array.from(collectAtoms(formula)).sort();
+        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]) ?? new Uint32Array(0), 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: evaluateClassical(formula, v),
+        }));
+        const subFormulaValues = valuations.map((v) => {
+            const vals = {};
+            subForms.forEach((sf) => {
+                vals[formulaToString(sf)] = evaluateClassical(sf, v);
+            });
+            return vals;
+        });
+        return {
+            variables: atoms,
+            rows,
+            isTautology: rows.every((r) => r.result),
+            isContradiction: rows.every((r) => !r.result),
+            isSatisfiable: rows.some((r) => r.result),
+            subFormulas: subFormulasInfo,
+            subFormulaValues,
+            satisfyingCount: rows.filter((r) => r.result).length,
+            totalCount: rows.length,
+        };
+    }
+    checkEquivalent(a, b) {
+        const wfA = this.checkWellFormed(a);
+        const wfB = this.checkWellFormed(b);
+        if (wfA.length > 0 || wfB.length > 0) {
+            return { status: 'error', diagnostics: [...wfA, ...wfB] };
+        }
+        const biconditional = { kind: 'biconditional', args: [a, b] };
+        const tt = this.truthTable(biconditional);
+        if (tt.isTautology) {
+            return {
+                status: 'valid',
+                output: `${formulaToString(a)} y ${formulaToString(b)} son EQUIVALENTES`,
+                truthTable: tt,
+                educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'equivalent', equiv: true }),
+                diagnostics: [],
+            };
+        }
+        const cm = tt.rows.find((r) => !r.result);
+        return {
+            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: [],
+        };
+    }
+}
+exports.ClassicalPropositional = ClassicalPropositional;
+//# sourceMappingURL=propositional.js.map