@stevenvo780/st-lang 3.0.2 → 3.1.1

package/dist/profiles/classical/propositional.js

@@ -704,7 +704,78 @@ function addDerivedFormula(state, formula, justification, premises) {
     state.known.set(hash, formula);
     return true;
 }
-function tryDerive(goal, theory, premiseNames) {
+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) {
+    return {
+        goal,
+        steps,
+        status: 'complete',
+        derivedFrom: premiseNames,
+        premiseRefs: buildPremiseRefs(theory, premiseNames),
+        method,
+        subproofs,
+        metadata: {
+            createdAt: new Date().toISOString(),
+            profile: theory.profile,
+        },
+    };
+}
+function isNegationOf(a, b) {
+    return a.kind === 'not' && !!a.args?.[0] && formulasEqual(a.args[0], b);
+}
+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 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(),
         steps: [],
@@ -712,7 +783,25 @@ function tryDerive(goal, theory, premiseNames) {
     };
     // Cargar premisas
     for (const name of premiseNames) {
-        const f = theory.axioms.get(name) || theory.theorems.get(name);
+        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({
@@ -724,6 +813,9 @@ function tryDerive(goal, theory, premiseNames) {
             state.known.set(formulaHash(f), f);
         }
     }
+    if (isExcludedMiddleFormula(goal)) {
+        addDerivedFormula(state, goal, 'Tercero excluido', []);
+    }
     // Intentar derivar con BFS aplicando reglas (optimizado)
     const maxIterations = 1000;
     let changed = true;
@@ -910,6 +1002,35 @@ function tryDerive(goal, theory, premiseNames) {
                         }
                     }
                 }
+                // 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] &&
@@ -948,6 +1069,32 @@ function tryDerive(goal, theory, premiseNames) {
                         ]) || 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]) {
@@ -1000,6 +1147,35 @@ function tryDerive(goal, theory, premiseNames) {
                         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 → ...)
@@ -1101,6 +1277,82 @@ function tryDerive(goal, theory, premiseNames) {
                 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]) {
@@ -1148,12 +1400,220 @@ function tryDerive(goal, theory, premiseNames) {
     if (state.known.has(formulaHash(goal))) {
         // Filtrar solo pasos relevantes para la derivación
         const relevantSteps = traceBack(state.steps, goal);
-        return {
-            goal,
-            steps: relevantSteps,
-            status: 'complete',
-            derivedFrom: premiseNames,
+        return buildProof(goal, relevantSteps, premiseNames, theory);
+    }
+    // --- Sub-derivaciones recursivas (antes del fallback semántico) ---
+    const MAX_SUB_DEPTH = 2;
+    // 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.justification.startsWith('Verificacion semantica'));
+            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.justification.startsWith('Premisa')) {
+                        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: [],
+                });
+                // Add sub-derivation steps (renumber, adjusting premise references)
+                const subStepMap = new Map();
+                for (const s of subProof.steps) {
+                    if (s.justification.startsWith('Premisa') && formulasEqual(s.formula, assumption)) {
+                        subStepMap.set(s.stepNumber, assumptionStepNum);
+                        continue;
+                    }
+                    if (s.justification.startsWith('Premisa')) {
+                        // Find existing premise step in main
+                        const existing = mainSteps.find((ms) => ms.justification.startsWith('Premisa') && 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),
+                    });
+                }
+                // 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],
+                });
+                return buildProof(goal, mainSteps, premiseNames, theory, 'natural_deduction', [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 = Array.from(state.known.values()).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.justification.startsWith('Verificacion semantica'));
+            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.justification.startsWith('Verificacion semantica'));
+            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.justification.startsWith('Premisa')) {
+                    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: [],
+            });
+            const leftStepMap = new Map();
+            for (const s of subProofL.steps) {
+                if (s.justification.startsWith('Premisa') && formulasEqual(s.formula, left)) {
+                    leftStepMap.set(s.stepNumber, leftAssumptionStep);
+                    continue;
+                }
+                if (s.justification.startsWith('Premisa')) {
+                    const existing = mainSteps.find((ms) => ms.justification.startsWith('Premisa') && 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),
+                });
+            }
+            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: [],
+            });
+            const rightStepMap = new Map();
+            for (const s of subProofR.steps) {
+                if (s.justification.startsWith('Premisa') && formulasEqual(s.formula, right)) {
+                    rightStepMap.set(s.stepNumber, rightAssumptionStep);
+                    continue;
+                }
+                if (s.justification.startsWith('Premisa')) {
+                    const existing = mainSteps.find((ms) => ms.justification.startsWith('Premisa') && 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),
+                });
+            }
+            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],
+            });
+            return buildProof(goal, mainSteps, premiseNames, theory, 'natural_deduction', [
+                subProofL,
+                subProofR,
+            ]);
+        }
     }
     // Fallback: verificar semánticamente
     const allAxiomFormulas = premiseNames
@@ -1224,12 +1684,7 @@ function tryDerive(goal, theory, premiseNames) {
                 state.known.set(goalHash, goal);
             }
             const relevantSteps = traceBack(state.steps, goal);
-            return {
-                goal,
-                steps: relevantSteps,
-                status: 'complete',
-                derivedFrom: premiseNames,
-            };
+            return buildProof(goal, relevantSteps, premiseNames, theory, 'semantic');
         }
     }
     return null;
@@ -1260,7 +1715,17 @@ function traceBack(steps, goal) {
         }
     }
     trace(goalStep.stepNumber);
-    return steps.filter((s) => needed.has(s.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 {
@@ -1456,6 +1921,96 @@ class ClassicalPropositional {
                 formula: goal,
             };
         }
+        // Semantic fallback: verify via SAT/truth-table whether goal follows from axioms
+        const allAxiomFormulas = premiseNames
+            .map((n) => theory.axioms.get(n) || theory.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 semanticProofSteps = [
+                ...premiseNames
+                    .map((n, i) => {
+                    const f = theory.axioms.get(n) || theory.theorems.get(n);
+                    return f
+                        ? {
+                            stepNumber: i + 1,
+                            formula: f,
+                            justification: `Premisa (${n})`,
+                            premises: [],
+                        }
+                        : null;
+                })
+                    .filter((s) => s !== null),
+                {
+                    stepNumber: premiseNames.length + 1,
+                    formula: goal,
+                    justification: 'Verificacion semantica (tautologia o consecuencia logica)',
+                    premises: premiseNames.map((_, i) => i + 1),
+                },
+            ];
+            const semanticProof = buildProof(goal, semanticProofSteps, premiseNames, theory, 'semantic');
+            return {
+                status: 'provable',
+                output: `${formulaToString(goal)} es DEMOSTRABLE desde la teoria`,
+                proof: semanticProof,
+                educationalNote: (0, educational_notes_1.pickEducationalNote)({ op: 'prove', ok: true }),
+                diagnostics: [],
+                formula: goal,
+            };
+        }
         return {
             status: 'refutable',
             output: `${formulaToString(goal)} NO es demostrable desde la teoria dada`,
@@ -1592,6 +2147,20 @@ class ClassicalPropositional {
         };
     }
     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 };