@stevenvo780/st-lang 2.0.4 → 2.5.0

package/dist/profiles/classical/propositional.js

@@ -6,6 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClassicalPropositional = void 0;
 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");
 // --- Utilidades de fórmulas ---
 function collectAtoms(f) {
     const atoms = new Set();
@@ -161,9 +166,7 @@ function formulaToString(f) {
                 ? `exists ${f.variable}(${formulaToString(f.args[0])})`
                 : 'exists ?(?)';
         case 'predicate':
-            return f.name
-                ? `${f.name}(${(f.params || []).join(', ')})`
-                : '?(...)';
+            return f.name ? `${f.name}(${(f.params || []).join(', ')})` : '?(...)';
         // Arithmetic
         case 'number':
             return f.value !== undefined ? String(f.value) : '?';
@@ -229,9 +232,21 @@ function toNNF(f) {
                 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);
+                    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);
+                    return simplify({
+                        kind: 'and',
+                        args: [
+                            { kind: 'not', args: [args[0]] },
+                            { kind: 'not', args: [args[1]] },
+                        ],
+                    }, false);
                 case 'xor':
                     return simplify({
                         kind: 'or',
@@ -299,6 +314,120 @@ function toNNF(f) {
     };
     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 distributeOrOverAnd(toNNF(f));
+}
+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 distributeAndOverOr(toNNF(f));
+}
+/**
+ * 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));
+}
 function formulasEqual(a, b) {
     if (a.kind !== b.kind)
         return false;
@@ -314,17 +443,7 @@ function formulasEqual(a, b) {
 }
 // --- Motor de derivación ---
 /** Límite duro de fórmulas derivadas para evitar explosión combinatoria */
-const MAX_KNOWN = 5000;
-/** Cuenta niveles de negación anidados en la raíz de una fórmula */
-function negationDepth(f) {
-    let d = 0;
-    let cur = f;
-    while (cur.kind === 'not' && cur.args?.[0]) {
-        d++;
-        cur = cur.args[0];
-    }
-    return d;
-}
+const MAX_KNOWN = 500;
 /** Profundidad máxima de negación en cualquier sub-fórmula */
 function maxNegationDepth(f) {
     if (f.kind === 'not' && f.args?.[0]) {
@@ -346,6 +465,22 @@ function maxNegationDepth(f) {
 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) {
     const hash = formulaHash(formula);
     if (state.known.has(hash))
@@ -381,7 +516,7 @@ function tryDerive(goal, theory, premiseNames) {
         }
     }
     // Intentar derivar con BFS aplicando reglas
-    const maxIterations = 200;
+    const maxIterations = 100;
     let changed = true;
     let iterations = 0;
     while (changed && iterations < maxIterations && state.known.size < MAX_KNOWN) {
@@ -403,8 +538,7 @@ function tryDerive(goal, theory, premiseNames) {
                     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;
+                    changed = addDerivedFormula(state, conclusion, 'Modus Ponens', [s1, s2]) || changed;
                 }
                 // Modus Ponens inverso: de (A -> B) y A, derivar B
                 if (f1.kind === 'implies' &&
@@ -414,8 +548,7 @@ function tryDerive(goal, theory, premiseNames) {
                     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;
+                    changed = addDerivedFormula(state, conclusion, 'Modus Ponens', [s1, s2]) || changed;
                 }
                 // Modus Tollens: de !B y (A -> B), derivar !A
                 if (f1.kind === 'not' &&
@@ -493,6 +626,88 @@ function tryDerive(goal, theory, premiseNames) {
                             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 (const f3 of currentFormulas) {
+                        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
+                        }
+                    }
+                }
+                // 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)) ||
@@ -526,8 +741,7 @@ function tryDerive(goal, theory, premiseNames) {
             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;
+                    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] }] };
@@ -577,6 +791,116 @@ function tryDerive(goal, theory, premiseNames) {
                         ]) || 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;
+            }
+            // 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 (const f2 of currentFormulas) {
+                    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))) {
@@ -789,10 +1113,27 @@ class ClassicalPropositional {
         }
         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.justification.startsWith('Premisa')) {
+                    rulesUsed.add(step.justification);
+                }
+            }
+            const reasoningType = rulesUsed.size > 0 ? Array.from(rulesUsed).join(', ') : 'Derivación directa';
             return {
                 status: 'provable',
                 output: `${formulaToString(goal)} derivado exitosamente`,
                 proof,
+                reasoningType,
+                reasoningSchema: rulesUsed.has('Modus Ponens')
+                    ? 'φ → ψ, φ ⊢ ψ'
+                    : rulesUsed.has('Modus Tollens')
+                        ? 'φ → ψ, ¬ψ ⊢ ¬φ'
+                        : rulesUsed.has('Silogismo Hipotetico')
+                            ? 'φ → ψ, ψ → χ ⊢ φ → χ'
+                            : undefined,
+                educationalNote: `Consecuencia semántica (⊨): Verificada — no existe valuación donde las premisas sean V y la conclusión F.\nConsecuencia sintáctica (⊢): Derivación formal completada en ${proof.steps.length} pasos.\nNota: Por completitud de la lógica proposicional clásica, ⊨ y ⊢ coinciden.`,
                 diagnostics: [],
                 formula: goal,
             };
@@ -813,9 +1154,11 @@ class ClassicalPropositional {
         const valuations = generateValuations(atoms);
         for (const v of valuations) {
             if (!evaluate(formula, v)) {
+                // #25: mark the countermodel valuation with ←
+                const valStr = atoms.map((a) => `${a}=${v[a] ? 'V' : 'F'}`).join(', ');
                 return {
                     status: 'invalid',
-                    output: `Contramodelo encontrado para ${formulaToString(formula)}`,
+                    output: `Contramodelo encontrado para ${formulaToString(formula)}\n  ← ${valStr}`,
                     model: { type: 'propositional', valuation: v },
                     diagnostics: [],
                     formula,
@@ -835,35 +1178,127 @@ class ClassicalPropositional {
             return { status: 'error', diagnostics: wf, formula };
         }
         const tt = this.truthTable(formula);
-        let explanation = `Formula: ${formulaToString(formula)}\n`;
-        explanation += `Variables: ${tt.variables.join(', ')}\n`;
-        explanation += `Tautologia: ${tt.isTautology ? 'si' : 'no'}\n`;
-        explanation += `Contradiccion: ${tt.isContradiction ? 'si' : 'no'}\n`;
-        explanation += `Satisfacible: ${tt.isSatisfiable ? 'si' : 'no'}\n`;
-        explanation += `Total valuaciones: ${tt.rows.length}\n`;
-        explanation += `Verdaderas: ${tt.rows.filter((r) => r.result).length}\n`;
-        explanation += `Falsas: ${tt.rows.filter((r) => !r.result).length}\n`;
+        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 valuations = generateValuations(atoms);
+        const subForms = getSubFormulas(formula);
         const rows = valuations.map((v) => ({
             valuation: v,
             result: evaluate(formula, v),
         }));
+        const subFormulasInfo = subForms.map((sf) => ({ formula: sf, label: formulaToString(sf) }));
+        const subFormulaValues = valuations.map((v) => {
+            const vals = {};
+            subForms.forEach((sf) => {
+                vals[formulaToString(sf)] = evaluate(sf, v);
+            });
+            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: subFormulaValues,
+            satisfyingCount: rows.filter((r) => r.result).length,
+            totalCount: rows.length,
         };
     }
     checkEquivalent(a, b) {