@stevenvo780/st-lang 3.1.0 → 3.1.2

package/dist/profiles/classical/propositional.js

@@ -38,6 +38,10 @@ function computeCollectAtoms(f) {
 }
 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':
@@ -311,6 +315,10 @@ function formulaToString(f) {
 }
 function computeFormulaToString(f) {
     switch (f.kind) {
+        case 'true':
+            return '⊤';
+        case 'false':
+            return '⊥';
         case 'atom':
             return f.name || '?';
         case 'not': {
@@ -425,6 +433,8 @@ function computeNNF(f) {
         const args = node.args || [];
         if (!negated) {
             switch (k) {
+                case 'true':
+                case 'false':
                 case 'atom':
                 case 'predicate':
                     return node;
@@ -468,6 +478,10 @@ function computeNNF(f) {
         }
         else {
             switch (k) {
+                case 'true':
+                    return { kind: 'false' };
+                case 'false':
+                    return { kind: 'true' };
                 case 'atom':
                 case 'predicate':
                     return { kind: 'not', args: [node] };
@@ -637,18 +651,105 @@ function getSubFormulas(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;
-    if (a.kind === 'atom' && b.kind === 'atom')
-        return a.name === b.name;
-    if (a.args && b.args) {
-        if (a.args.length !== b.args.length)
-            return false;
-        const bArgs = b.args;
-        return a.args.every((arg, i) => formulasEqual(arg, bArgs[i]));
+    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));
+        }
     }
-    return false;
 }
 // --- Motor de derivación ---
 /** Límite duro de fórmulas derivadas para evitar explosión combinatoria */
@@ -690,7 +791,7 @@ function isRelevantToGoal(f, goal) {
     };
     return checkSub(goal);
 }
-function addDerivedFormula(state, formula, justification, premises) {
+function addDerivedFormula(state, formula, justification, premises, source = 'rule') {
     const hash = formulaHash(formula);
     if (state.known.has(hash))
         return false;
@@ -700,10 +801,82 @@ function addDerivedFormula(state, formula, justification, premises) {
         formula,
         justification,
         premises,
+        source,
     });
     state.known.set(hash, formula);
     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) {
+    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(),
@@ -712,7 +885,25 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
     };
     // 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({
@@ -720,10 +911,14 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
                 formula: f,
                 justification: `Premisa (${name})`,
                 premises: [],
+                source: 'premise',
             });
             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;
@@ -928,7 +1123,9 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
                     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);
+                        const disjFormula = state.known.get(disjHash) ?? state.known.get(disjHashRev);
+                        if (!disjFormula)
+                            continue;
                         changed =
                             addDerivedFormula(state, qs, 'Dilema Constructivo', [
                                 findStep(state.steps, f1),
@@ -975,6 +1172,32 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
                         ]) || 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]) {
@@ -1027,6 +1250,35 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
                         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 → ...)
@@ -1251,21 +1503,13 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
     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]) {
+    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
@@ -1282,14 +1526,14 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
         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'));
+            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.justification.startsWith('Premisa')) {
+                    if (s.source === 'premise') {
                         stepNum++;
                         mainSteps.push({ ...s, stepNumber: stepNum, premises: [] });
                     }
@@ -1302,18 +1546,18 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
                     formula: assumption,
                     justification: 'Supuesto (para prueba condicional)',
                     premises: [],
+                    source: 'assumption',
                 });
                 // Add sub-derivation steps (renumber, adjusting premise references)
-                const subStepOffset = stepNum;
                 const subStepMap = new Map();
                 for (const s of subProof.steps) {
-                    if (s.justification.startsWith('Premisa') && formulasEqual(s.formula, assumption)) {
+                    if (s.source === 'premise' && formulasEqual(s.formula, assumption)) {
                         subStepMap.set(s.stepNumber, assumptionStepNum);
                         continue;
                     }
-                    if (s.justification.startsWith('Premisa')) {
+                    if (s.source === 'premise') {
                         // Find existing premise step in main
-                        const existing = mainSteps.find((ms) => ms.justification.startsWith('Premisa') && formulasEqual(ms.formula, s.formula));
+                        const existing = mainSteps.find((ms) => ms.source === 'premise' && formulasEqual(ms.formula, s.formula));
                         if (existing) {
                             subStepMap.set(s.stepNumber, existing.stepNumber);
                             continue;
@@ -1326,23 +1570,21 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
                         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);
+                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 {
-                    goal,
-                    steps: mainSteps,
-                    status: 'complete',
-                    derivedFrom: premiseNames,
-                };
+                return buildProof(goal, mainSteps, premiseNames, theory, 'natural_deduction', [subProof]);
             }
         }
     }
@@ -1351,8 +1593,10 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
     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];
+            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,
@@ -1367,7 +1611,7 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
             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'));
+            const isSyntacticL = subProofL.steps.every((s) => s.source !== 'semantic');
             if (!isSyntacticL)
                 continue;
             // Try to derive goal assuming right
@@ -1384,7 +1628,7 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
             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'));
+            const isSyntacticR = subProofR.steps.every((s) => s.source !== 'semantic');
             if (!isSyntacticR)
                 continue;
             // Both cases succeed — build proof by cases
@@ -1392,7 +1636,7 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
             let stepNum = 0;
             // Copy premise steps
             for (const s of state.steps) {
-                if (s.justification.startsWith('Premisa')) {
+                if (s.source === 'premise') {
                     stepNum++;
                     mainSteps.push({ ...s, stepNumber: stepNum, premises: [] });
                 }
@@ -1406,15 +1650,16 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
                 formula: left,
                 justification: 'Supuesto (caso izquierdo)',
                 premises: [],
+                source: 'assumption',
             });
             const leftStepMap = new Map();
             for (const s of subProofL.steps) {
-                if (s.justification.startsWith('Premisa') && formulasEqual(s.formula, left)) {
+                if (s.source === 'premise' && 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 (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;
@@ -1427,6 +1672,7 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
                     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;
@@ -1438,15 +1684,16 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
                 formula: right,
                 justification: 'Supuesto (caso derecho)',
                 premises: [],
+                source: 'assumption',
             });
             const rightStepMap = new Map();
             for (const s of subProofR.steps) {
-                if (s.justification.startsWith('Premisa') && formulasEqual(s.formula, right)) {
+                if (s.source === 'premise' && 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 (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;
@@ -1459,6 +1706,7 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
                     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;
@@ -1469,13 +1717,13 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
                 formula: goal,
                 justification: 'Eliminacion de disyuncion (prueba por casos)',
                 premises: [disjStepNum, leftGoalStep, rightGoalStep],
+                subproofs: [subProofL, subProofR],
+                source: 'rule',
             });
-            return {
-                goal,
-                steps: mainSteps,
-                status: 'complete',
-                derivedFrom: premiseNames,
-            };
+            return buildProof(goal, mainSteps, premiseNames, theory, 'natural_deduction', [
+                subProofL,
+                subProofR,
+            ]);
         }
     }
     // Fallback: verificar semánticamente
@@ -1543,16 +1791,12 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
                     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 {
-                goal,
-                steps: relevantSteps,
-                status: 'complete',
-                derivedFrom: premiseNames,
-            };
+            return buildProof(goal, relevantSteps, premiseNames, theory, 'semantic');
         }
     }
     return null;
@@ -1583,7 +1827,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 {
@@ -1762,28 +2016,152 @@ class ClassicalPropositional {
             };
         }
     }
-    prove(goal, theory) {
+    prove(goal, theory, premises) {
         const wf = this.checkWellFormed(goal);
         if (wf.length > 0) {
             return { status: 'error', diagnostics: wf, formula: goal };
         }
-        const premiseNames = Array.from(theory.axioms.keys());
-        const proof = tryDerive(goal, theory, premiseNames);
+        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: `${formulaToString(goal)} es DEMOSTRABLE desde la teoria`,
+                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: [],
+                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 es demostrable desde la teoria dada`,
+            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: [],
+            diagnostics,
             formula: goal,
         };
     }
@@ -1797,14 +2175,17 @@ class ClassicalPropositional {
             // Build reasoning info
             const rulesUsed = new Set();
             for (const step of proof.steps) {
-                if (!step.justification.startsWith('Premisa')) {
+                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: `${formulaToString(goal)} derivado exitosamente`,
+                output: isSemantic
+                    ? `${formulaToString(goal)} derivado (verificación semántica, sin derivación sintáctica)`
+                    : `${formulaToString(goal)} derivado exitosamente`,
                 proof,
                 reasoningType,
                 reasoningSchema: rulesUsed.has('Modus Ponens')
@@ -1825,8 +2206,8 @@ class ClassicalPropositional {
             };
         }
         return {
-            status: 'refutable',
-            output: `No se puede derivar ${formulaToString(goal)} desde las premisas dadas`,
+            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,
@@ -1915,6 +2296,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 };