@stevenvo780/st-lang 2.6.0 → 2.7.0

package/dist/profiles/classical/first-order.js

@@ -1,6 +1,6 @@
 "use strict";
 // ============================================================
-// ST Classical First-Order — Motor de Tableau Sistematico (v2 Perfect)
+// ST Classical First-Order — Motor de Tableau Sistematico (Hardened)
 // ============================================================
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClassicalFirstOrder = void 0;
@@ -79,14 +79,11 @@ function skolemize(f) {
         }
         return node;
     }
-    const rawMatrix = process(prenex);
-    // Restore remaining foralls (Skolemization removes existentials, keeps foralls usually implicitly but we make them explicit)
-    const finalRes = rawMatrix;
-    return finalRes; // Simplification: we just return the matrix, standard skolemization implicitly universalizes
+    return process(prenex);
 }
 class ClassicalFirstOrder {
     name = 'classical.first_order';
-    description = 'Logica clasica de primer orden (FOL) — Motor de Tableau v2';
+    description = 'Logica clasica de primer orden (FOL) — Motor de Tableau Hardened';
     checkWellFormed(formula) {
         const diags = [];
         const walk = (f) => {
@@ -102,12 +99,11 @@ class ClassicalFirstOrder {
     checkValid(formula) {
         const negated = (0, propositional_1.toNNF)({ kind: 'not', args: [formula] });
         const res = this.solve([{ formula: negated }]);
-        const isClosed = res.closed;
         return {
-            status: isClosed ? 'valid' : 'invalid',
-            output: isClosed
-                ? `${(0, propositional_1.formulaToString)(formula)} es VÁLIDA en FOL`
-                : `${(0, propositional_1.formulaToString)(formula)} NO es válida (tiene un contramodelo)`,
+            status: res.closed ? 'valid' : 'invalid',
+            output: res.closed
+                ? `${(0, propositional_1.formulaToString)(formula)} es VÁLIDA`
+                : `${(0, propositional_1.formulaToString)(formula)} NO es válida`,
             tableauTrace: res.trace,
             diagnostics: [],
             formula,
@@ -130,10 +126,9 @@ class ClassicalFirstOrder {
             { formula: (0, propositional_1.toNNF)({ kind: 'not', args: [goal] }) },
         ];
         const res = this.solve(nodes);
-        const isClosed = res.closed;
         return {
-            status: isClosed ? 'provable' : 'refutable',
-            output: isClosed ? 'Demostrado' : 'No demostrable',
+            status: res.closed ? 'provable' : 'refutable',
+            output: res.closed ? 'Demostrado' : 'No demostrable',
             tableauTrace: res.trace,
             diagnostics: [],
             formula: goal,
@@ -148,68 +143,10 @@ class ClassicalFirstOrder {
             { formula: (0, propositional_1.toNNF)({ kind: 'not', args: [goal] }) },
         ];
         const res = this.solve(nodes);
-        // Build proof steps from tableau trace
-        const proof = { goal, steps: [], status: 'incomplete' };
-        let stepNum = 0;
-        // Add premises as steps
-        for (let i = 0; i < premises.length; i++) {
-            stepNum++;
-            const f = formulas[i];
-            if (f) {
-                proof.steps.push({
-                    stepNumber: stepNum,
-                    formula: f,
-                    justification: `Premisa (${premises[i]})`,
-                    premises: [],
-                });
-            }
-        }
-        // Parse tableau trace to extract named quantifier rules
-        for (const traceLine of res.trace) {
-            if (traceLine.includes('Instanciación Universal UI') ||
-                traceLine.includes('Gamma') ||
-                traceLine.includes('gamma')) {
-                stepNum++;
-                proof.steps.push({
-                    stepNumber: stepNum,
-                    formula: goal,
-                    justification: 'Instanciación Universal (UI): ∀xφ(x) ⊢ φ(a)',
-                    premises: [],
-                });
-            }
-            if (traceLine.includes('Instanciación Existencial EI') ||
-                traceLine.includes('Delta') ||
-                traceLine.includes('delta')) {
-                stepNum++;
-                proof.steps.push({
-                    stepNumber: stepNum,
-                    formula: goal,
-                    justification: 'Instanciación Existencial (EI): ∃xφ(x) ⊢ φ(c) [c nueva]',
-                    premises: [],
-                });
-            }
-        }
-        // Final step
-        if (res.closed) {
-            stepNum++;
-            proof.steps.push({
-                stepNumber: stepNum,
-                formula: goal,
-                justification: 'Demostrado por refutación — todas las ramas del tableau cerradas',
-                premises: [],
-            });
-            proof.status = 'complete';
-        }
-        const output = res.closed
-            ? `Derivado con éxito mediante tableau de primer orden.\n  Reglas de cuantificadores aplicadas:\n    UI: Instanciación Universal — ∀xφ(x) ⊢ φ(a)\n    EI: Instanciación Existencial — ∃xφ(x) ⊢ φ(c) [c nueva]\n    UG: Generalización Universal — φ(a) [a arbitrario] ⊢ ∀xφ(x)\n    EG: Generalización Existencial — φ(a) ⊢ ∃xφ(x)`
-            : 'No se pudo derivar.';
         return {
             status: res.closed ? 'provable' : 'refutable',
-            output,
-            proof: res.closed ? proof : undefined,
+            output: res.closed ? 'Derivado' : 'No derivable',
             tableauTrace: res.trace,
-            reasoningType: res.closed ? 'Tableau de primer orden (refutación)' : undefined,
-            reasoningSchema: res.closed ? 'Γ, ¬φ ⊢ ⊥  ∴  Γ ⊢ φ' : undefined,
             diagnostics: [],
             formula: goal,
         };
@@ -217,212 +154,73 @@ class ClassicalFirstOrder {
     countermodel(formula) {
         const nnf = (0, propositional_1.toNNF)(formula);
         const res = this.solve([{ formula: { kind: 'not', args: [nnf] } }]);
-        if (!res.closed) {
-            // Extract domain and interpretation from open branch trace
-            const domain = new Set();
-            const interpretations = new Map();
-            for (const line of res.trace) {
-                // Collect constants mentioned in trace
-                const constMatch = line.match(/\b(c\d+|[a-d])\b/g);
-                if (constMatch) {
-                    for (const c of constMatch)
-                        domain.add(c);
-                }
-            }
-            if (domain.size === 0)
-                domain.add('a');
-            // Build output
-            let output = `Contramodelo encontrado:\n`;
-            output += `  Dominio D = {${Array.from(domain).join(', ')}}\n`;
-            output += `  Interpretación:\n`;
-            // Collect predicates from formula
-            const preds = new Map();
-            const collectPreds = (f) => {
-                if (f.kind === 'predicate' && f.name) {
-                    preds.set(f.name, (f.params || []).length);
-                }
-                f.args?.forEach(collectPreds);
-            };
-            collectPreds(formula);
-            for (const [pred, arity] of preds) {
-                const interp = interpretations.get(pred);
-                if (interp && interp.size > 0) {
-                    output += `    ${pred} = {${Array.from(interp).join(', ')}} (aridad ${arity})\n`;
-                }
-                else {
-                    output += `    ${pred} = {} (vacío, aridad ${arity})\n`;
-                }
-            }
-            output += `  → La fórmula no es válida`;
-            return {
-                status: 'invalid',
-                output,
-                model: {
-                    type: 'first_order',
-                    valuation: Object.fromEntries(Array.from(preds.keys()).map((p) => [p, false])),
-                },
-                tableauTrace: res.trace,
-                diagnostics: [],
-                formula,
-            };
-        }
         return {
-            status: 'valid',
-            output: `No existen contramodelos — la fórmula es válida en FOL.`,
+            status: res.closed ? 'valid' : 'invalid',
+            output: res.closed ? 'Válida' : 'Inválida',
             tableauTrace: res.trace,
             diagnostics: [],
             formula,
         };
     }
-    explain(formula) {
-        const nnf = (0, propositional_1.toNNF)(formula);
-        const prenex = toPrenex(formula);
-        const skolem = skolemize(formula);
-        // Collect quantifiers, predicates, variables
-        const quantifiers = [];
-        const predicates = new Map(); // name -> arity
-        const freeVars = new Set();
-        const boundVars = new Set();
-        const collectInfo = (f, bound) => {
-            if (f.kind === 'forall' || f.kind === 'exists') {
-                const v = f.variable || '_';
-                const innerStr = f.args?.[0] ? (0, propositional_1.formulaToString)(f.args[0]) : '?';
-                quantifiers.push({
-                    kind: f.kind === 'forall' ? '∀' : '∃',
-                    variable: v,
-                    scope: innerStr,
-                });
-                const newBound = new Set(bound);
-                newBound.add(v);
-                boundVars.add(v);
-                if (f.args)
-                    f.args.forEach((a) => collectInfo(a, newBound));
-                return;
-            }
-            if (f.kind === 'predicate' && f.name) {
-                const arity = (f.params || []).length;
-                predicates.set(f.name, arity);
-                for (const p of f.params || []) {
-                    if (!bound.has(p))
-                        freeVars.add(p);
-                }
-            }
-            if (f.kind === 'atom' && f.name) {
-                predicates.set(f.name, 0);
-            }
-            if (f.args)
-                f.args.forEach((a) => collectInfo(a, bound));
-        };
-        collectInfo(formula, new Set());
-        let out = `Análisis de Fórmula en Primer Orden:\n`;
-        out += `  Fórmula original: ${(0, propositional_1.formulaToString)(formula)}\n`;
-        // Syntactic analysis
-        out += `\nAnálisis sintáctico:\n`;
-        if (quantifiers.length > 0) {
-            const qStrs = quantifiers.map((q) => `${q.kind}${q.variable} (${q.kind === '∀' ? 'universal' : 'existencial'})`);
-            out += `  Cuantificadores: ${qStrs.join(', ')}\n`;
-            for (const q of quantifiers) {
-                out += `  Alcance de ${q.kind}${q.variable}: ${q.scope}\n`;
+    explain(_formula) {
+        return { status: 'unknown', output: 'Explain no implementado en Hardened', diagnostics: [] };
+    }
+    checkEquivalent(a, b) {
+        const biconditional = { kind: 'biconditional', args: [a, b] };
+        return this.checkValid(biconditional);
+    }
+    collectConstants(f, bound) {
+        const result = new Set();
+        if (f.kind === 'predicate' && f.params) {
+            for (const p of f.params) {
+                if (!bound.has(p))
+                    result.add(p);
             }
         }
-        else {
-            out += `  Cuantificadores: ninguno (fórmula proposicional con predicados)\n`;
-        }
-        if (predicates.size > 0) {
-            const predStrs = Array.from(predicates.entries()).map(([n, a]) => `${n}/${a} (aridad ${a})`);
-            out += `  Predicados: ${predStrs.join(', ')}\n`;
+        if (f.kind === 'atom' && f.name && !bound.has(f.name)) {
+            // atoms used as term-like references (e.g. P(a) where a is a constant)
         }
-        if (boundVars.size > 0)
-            out += `  Variables ligadas: ${Array.from(boundVars).join(', ')}\n`;
-        if (freeVars.size > 0) {
-            out += `  Variables libres: ${Array.from(freeVars).join(', ')}\n`;
+        if (f.kind === 'forall' || f.kind === 'exists') {
+            const inner = new Set(bound);
+            if (f.variable)
+                inner.add(f.variable);
+            for (const s of this.collectConstants((f.args || [])[0], inner))
+                result.add(s);
         }
-        else {
-            out += `  Variables libres: ninguna (sentencia cerrada)\n`;
-        }
-        // Quantifier alternation depth
-        let altDepth = 0;
-        let lastQ = '';
-        for (const q of quantifiers) {
-            if (lastQ && lastQ !== q.kind)
-                altDepth++;
-            lastQ = q.kind;
-        }
-        out += `  Alternancia de cuantificadores: ${altDepth}\n`;
-        out += `  Profundidad de cuantificadores: ${quantifiers.length}\n`;
-        // Normal forms
-        out += `\nFormas normales:\n`;
-        out += `  NNF: ${(0, propositional_1.formulaToString)(nnf)}\n`;
-        out += `  PNF: ${(0, propositional_1.formulaToString)(prenex)}\n`;
-        out += `  Skolem: ${(0, propositional_1.formulaToString)(skolem)}\n`;
-        // Natural language interpretation
-        if (quantifiers.length === 1 &&
-            quantifiers[0].kind === '∀' &&
-            formula.args?.[0]?.kind === 'implies' &&
-            predicates.size === 2) {
-            const pNames = Array.from(predicates.keys());
-            out += `\nInterpretación natural: "Para todo ${quantifiers[0].variable}, si ${quantifiers[0].variable} es ${pNames[0]} entonces ${quantifiers[0].variable} es ${pNames[1]}"\n`;
-            out += `Lectura categórica: "Todo ${pNames[0]} es ${pNames[1]}" (proposición tipo A)\n`;
+        else if (f.args) {
+            for (const a of f.args) {
+                for (const s of this.collectConstants(a, bound))
+                    result.add(s);
+            }
         }
-        // Validity check
-        const res = this.solve([{ formula: (0, propositional_1.toNNF)({ kind: 'not', args: [formula] }) }]);
-        out += `\nEstatus: ${res.closed ? 'VÁLIDA (demostrada por tableau)' : 'INVÁLIDA (rama abierta encontrada)'}`;
-        return {
-            status: res.closed ? 'valid' : 'invalid',
-            output: out,
-            tableauTrace: res.trace,
-            normalForms: {
-                nnf: (0, propositional_1.formulaToString)(nnf),
-                pnf: (0, propositional_1.formulaToString)(prenex),
-                skolem: (0, propositional_1.formulaToString)(skolem),
-            },
-            diagnostics: [],
-            formula,
-        };
-    }
-    checkEquivalent(a, b) {
-        const biconditional = { kind: 'biconditional', args: [a, b] };
-        const result = this.checkValid(biconditional);
-        const fA = (0, propositional_1.formulaToString)(a);
-        const fB = (0, propositional_1.formulaToString)(b);
-        return {
-            status: result.status === 'valid' ? 'valid' : 'invalid',
-            output: result.status === 'valid'
-                ? `${fA} y ${fB} son EQUIVALENTES en FOL`
-                : `${fA} y ${fB} NO son equivalentes en FOL`,
-            diagnostics: [],
-        };
+        return result;
     }
     solve(initialNodes) {
         varCounter = 0;
         skolemCounter = 0;
         const constants = new Set(['c0']);
-        const collect = (f) => {
-            if (f.kind === 'predicate' && f.params) {
-                for (const p of f.params)
-                    if (!p.match(/^[xyz]/))
-                        constants.add(p);
+        for (const node of initialNodes) {
+            for (const c of this.collectConstants(node.formula, new Set())) {
+                constants.add(c);
             }
-            f.args?.forEach(collect);
-        };
-        initialNodes.forEach((n) => collect(n.formula));
+        }
         const trace = [];
         const closed = this.solveRecursive(initialNodes, constants, new Set(), 0, trace);
         return { closed, trace };
     }
     solveRecursive(nodes, constants, processed, depth, trace) {
-        if (depth > 3000) {
-            trace.push(`[${depth}] ⚠ Se superó la profundidad máxima permitida (3000). Evaluando recursividad forzada.`);
+        if (depth > 200) {
+            trace.push(`[${depth}] ⚠ Se alcanzó profundidad máxima de seguridad (200).`);
             return false;
         }
         if (nodes.length === 0)
             return false;
-        // 1. Contradicción robusta (comparación canónica)
+        // Contradicción
         for (const n1 of nodes) {
             if (n1.formula.kind === 'not' && n1.formula.args) {
                 const atom = n1.formula.args[0];
                 if (nodes.some((n2) => this.isEqual(n2.formula, atom))) {
-                    trace.push(`[${depth}] ✕ Rama cerrada por contradicción con ${(0, propositional_1.formulaToString)(atom)}`);
+                    trace.push(`[${depth}] ✕ Rama cerrada por contradicción`);
                     return true;
                 }
             }
@@ -430,29 +228,12 @@ class ClassicalFirstOrder {
         const type = (f) => {
             if (f.kind === 'and')
                 return 'alfa';
-            if (f.kind === 'or' || f.kind === 'implies')
-                return 'beta';
-            if (f.kind === 'biconditional')
-                return 'beta';
             if (f.kind === 'exists')
                 return 'delta';
             if (f.kind === 'forall')
                 return 'gamma';
-            if (f.kind === 'not') {
-                const inner = (f.args || [])[0];
-                if (inner) {
-                    if (inner.kind === 'and')
-                        return 'beta';
-                    if (inner.kind === 'or')
-                        return 'alfa';
-                    if (inner.kind === 'implies')
-                        return 'alfa';
-                    if (inner.kind === 'exists')
-                        return 'gamma';
-                    if (inner.kind === 'forall')
-                        return 'delta';
-                }
-            }
+            if (f.kind === 'or' || f.kind === 'implies')
+                return 'beta';
             return 'atom';
         };
         const priorities = ['alfa', 'delta', 'gamma', 'beta'];
@@ -463,8 +244,7 @@ class ClassicalFirstOrder {
             const node = nodes[idx];
             const rest = nodes.filter((_, i) => i !== idx);
             const { formula: f } = node;
-            const args = f.args || [];
-            const key = this.formulaHash(f);
+            const key = (0, propositional_1.formulaToString)(f);
             if (p !== 'gamma' && p !== 'atom' && processed.has(key))
                 return this.solveRecursive(rest, constants, processed, depth, trace);
             const nextProcessed = new Set(processed);
@@ -472,127 +252,45 @@ class ClassicalFirstOrder {
                 nextProcessed.add(key);
             switch (f.kind) {
                 case 'and':
-                    trace.push(`[${depth}] Alfa (∧): ${(0, propositional_1.formulaToString)(f)}`);
-                    return this.solveRecursive([{ formula: args[0] }, { formula: args[1] }, ...rest], constants, nextProcessed, depth + 1, trace);
+                    return this.solveRecursive([{ formula: f.args[0] }, { formula: f.args[1] }, ...rest], constants, nextProcessed, depth + 1, trace);
                 case 'exists': {
-                    const variable = f.variable;
-                    if (!args[0] || !variable)
-                        return false;
                     const newC = `c${constants.size}`;
-                    trace.push(`[${depth}] Delta (∃ - Instanciación Existencial EI): ${(0, propositional_1.formulaToString)(f)} -> asignando cte nueva ${newC}`);
                     const nextConstants = new Set(constants).add(newC);
-                    return this.solveRecursive([{ formula: this.substitute(args[0], variable, newC) }, ...rest], nextConstants, nextProcessed, depth + 1, trace);
+                    return this.solveRecursive([{ formula: this.substitute(f.args[0], f.variable, newC) }, ...rest], nextConstants, nextProcessed, depth + 1, trace);
                 }
                 case 'forall': {
-                    const variable = f.variable;
-                    if (!args[0] || !variable)
-                        return false;
-                    const newInsts = [];
-                    for (const c of constants) {
-                        const instKey = `gamma:${c}:${key}`;
-                        if (!processed.has(instKey)) {
-                            newInsts.push({ formula: this.substitute(args[0], variable, c) });
-                            processed.add(instKey);
-                        }
+                    const gammaKey = `gamma_count:${key}`;
+                    const proc = processed;
+                    const gammaCount = proc.__gammaCounters?.get(gammaKey) ?? 0;
+                    if (gammaCount >= 20) {
+                        trace.push(`[${depth}] ⚠ Límite Gamma alcanzado.`);
+                        return this.solveRecursive(rest, constants, nextProcessed, depth, trace);
                     }
-                    if (newInsts.length > 0) {
-                        trace.push(`[${depth}] Gamma (∀ - Instanciación Universal UI): ${(0, propositional_1.formulaToString)(f)} -> con instantes actuales`);
-                        return this.solveRecursive([...newInsts, ...nodes], constants, processed, depth + 1, trace);
-                    }
-                    return this.solveRecursive(rest, constants, nextProcessed, depth, trace);
+                    if (!proc.__gammaCounters)
+                        proc.__gammaCounters = new Map();
+                    proc.__gammaCounters.set(gammaKey, gammaCount + 1);
+                    const newInsts = Array.from(constants).map((c) => ({
+                        formula: this.substitute(f.args[0], f.variable, c),
+                    }));
+                    return this.solveRecursive([...newInsts, ...nodes], constants, processed, depth + 1, trace);
                 }
                 case 'or':
-                    trace.push(`[${depth}] Beta (∨): ${(0, propositional_1.formulaToString)(f)} -> Bifurcando`);
-                    return (this.solveRecursive([{ formula: args[0] }, ...rest], constants, nextProcessed, depth + 1, [...trace, `[${depth}]    -> Rama 1: ${(0, propositional_1.formulaToString)(args[0])}`]) &&
-                        this.solveRecursive([{ formula: args[1] }, ...rest], constants, nextProcessed, depth + 1, [...trace, `[${depth}]    -> Rama 2: ${(0, propositional_1.formulaToString)(args[1])}`]));
+                    return (this.solveRecursive([{ formula: f.args[0] }, ...rest], constants, nextProcessed, depth + 1, trace) &&
+                        this.solveRecursive([{ formula: f.args[1] }, ...rest], constants, nextProcessed, depth + 1, trace));
                 case 'implies':
-                    trace.push(`[${depth}] Beta (→): ${(0, propositional_1.formulaToString)(f)} -> Bifurcando`);
-                    return (this.solveRecursive([{ formula: { kind: 'not', args: [args[0]] } }, ...rest], constants, nextProcessed, depth + 1, [...trace, `[${depth}]    -> Rama 1: ¬${(0, propositional_1.formulaToString)(args[0])}`]) &&
-                        this.solveRecursive([{ formula: args[1] }, ...rest], constants, nextProcessed, depth + 1, [...trace, `[${depth}]    -> Rama 2: ${(0, propositional_1.formulaToString)(args[1])}`]));
-                case 'biconditional':
-                    trace.push(`[${depth}] Beta (↔): ${(0, propositional_1.formulaToString)(f)}`);
-                    return (this.solveRecursive([{ formula: args[0] }, { formula: args[1] }, ...rest], constants, nextProcessed, depth + 1, [...trace]) &&
-                        this.solveRecursive([
-                            { formula: { kind: 'not', args: [args[0]] } },
-                            { formula: { kind: 'not', args: [args[1]] } },
-                            ...rest,
-                        ], constants, nextProcessed, depth + 1, [...trace]));
-                case 'not': {
-                    const inner = args[0];
-                    if (!inner)
-                        return false;
-                    switch (inner.kind) {
-                        case 'and':
-                            trace.push(`[${depth}] Beta (¬∧): ${(0, propositional_1.formulaToString)(f)}`);
-                            return ((inner.args || []).length >= 2 &&
-                                this.solveRecursive([{ formula: { kind: 'not', args: [inner.args[0]] } }, ...rest], constants, nextProcessed, depth + 1, [...trace]) &&
-                                this.solveRecursive([{ formula: { kind: 'not', args: [inner.args[1]] } }, ...rest], constants, nextProcessed, depth + 1, [...trace]));
-                        case 'or':
-                            trace.push(`[${depth}] Alfa (¬∨): ${(0, propositional_1.formulaToString)(f)}`);
-                            return this.solveRecursive([
-                                ...(inner.args || []).map((a) => ({
-                                    formula: { kind: 'not', args: [a] },
-                                })),
-                                ...rest,
-                            ], constants, nextProcessed, depth + 1, trace);
-                        case 'implies':
-                            trace.push(`[${depth}] Alfa (¬→): ${(0, propositional_1.formulaToString)(f)}`);
-                            return this.solveRecursive([
-                                { formula: (inner.args || [])[0] },
-                                { formula: { kind: 'not', args: [(inner.args || [])[1]] } },
-                                ...rest,
-                            ], constants, nextProcessed, depth + 1, trace);
-                        case 'forall': {
-                            const variable = inner.variable;
-                            if (!(inner.args || [])[0] || !variable)
-                                return false;
-                            const newC = `c${constants.size}`;
-                            trace.push(`[${depth}] Delta (¬∀): ${(0, propositional_1.formulaToString)(f)} -> instanciando con ${newC} (EI)`);
-                            const nextConstants = new Set(constants).add(newC);
-                            return this.solveRecursive([
-                                {
-                                    formula: {
-                                        kind: 'not',
-                                        args: [this.substitute(inner.args[0], variable, newC)],
-                                    },
-                                },
-                                ...rest,
-                            ], nextConstants, nextProcessed, depth + 1, trace);
-                        }
-                        case 'exists': {
-                            const variable = inner.variable;
-                            if (!(inner.args || [])[0] || !variable)
-                                return false;
-                            const negForall = {
-                                kind: 'forall',
-                                variable,
-                                args: [{ kind: 'not', args: [inner.args[0]] }],
-                            };
-                            trace.push(`[${depth}] Gamma (¬∃): ${(0, propositional_1.formulaToString)(f)} -> transformando a ∀¬ (UG/UI prep)`);
-                            return this.solveRecursive([{ formula: negForall }, ...rest], constants, nextProcessed, depth + 1, trace);
-                        }
-                        case 'not':
-                            trace.push(`[${depth}] Doble negación: ${(0, propositional_1.formulaToString)(f)}`);
-                            return this.solveRecursive([{ formula: (inner.args || [])[0] }, ...rest], constants, nextProcessed, depth + 1, trace);
-                    }
-                    break;
-                }
+                    // A -> B branches into: ¬A or B
+                    return (this.solveRecursive([{ formula: { kind: 'not', args: [f.args[0]] } }, ...rest], constants, nextProcessed, depth + 1, trace) &&
+                        this.solveRecursive([{ formula: f.args[1] }, ...rest], constants, nextProcessed, depth + 1, trace));
             }
         }
-        trace.push(`[${depth}] ✓ Rama saturada y ABIERTA.`);
         return false;
     }
-    formulaHash(f) {
-        return (0, propositional_1.formulaToString)(f);
-    }
     substitute(f, v, c) {
         const sub = (n) => {
             if (n.kind === 'predicate' && n.params)
                 return { ...n, params: n.params.map((p) => (p === v ? c : p)) };
             if (n.kind === 'atom' && n.name === v)
                 return { ...n, name: c };
-            if ((n.kind === 'forall' || n.kind === 'exists') && n.variable === v)
-                return n;
             if (n.args)
                 return { ...n, args: n.args.map(sub) };
             return n;
@@ -600,26 +298,7 @@ class ClassicalFirstOrder {
         return sub(f);
     }
     isEqual(a, b) {
-        if (a.kind !== b.kind)
-            return false;
-        if (a.kind === 'atom' && b.kind === 'atom')
-            return a.name === b.name;
-        if (a.kind === 'predicate' && b.kind === 'predicate') {
-            if (a.name !== b.name)
-                return false;
-            const pa = a.params || [];
-            const pb = b.params || [];
-            if (pa.length !== pb.length)
-                return false;
-            return pa.every((p, i) => p === pb[i]);
-        }
-        if (a.variable !== b.variable)
-            return false;
-        const aa = a.args || [];
-        const ba = b.args || [];
-        if (aa.length !== ba.length)
-            return false;
-        return aa.every((ai, i) => this.isEqual(ai, ba[i]));
+        return (0, propositional_1.formulaToString)(a) === (0, propositional_1.formulaToString)(b);
     }
 }
 exports.ClassicalFirstOrder = ClassicalFirstOrder;