@stevenvo780/st-lang 3.1.0 → 3.1.1

package/dist/profiles/classical/propositional.js

@@ -704,6 +704,77 @@ function addDerivedFormula(state, formula, justification, premises) {
     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 +783,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({
@@ -724,6 +813,9 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
             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 +1020,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 +1069,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 +1147,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 +1400,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
@@ -1304,7 +1445,6 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
                     premises: [],
                 });
                 // 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)) {
@@ -1330,19 +1470,15 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
                 }
                 // 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],
                 });
-                return {
-                    goal,
-                    steps: mainSteps,
-                    status: 'complete',
-                    derivedFrom: premiseNames,
-                };
+                return buildProof(goal, mainSteps, premiseNames, theory, 'natural_deduction', [subProof]);
             }
         }
     }
@@ -1351,8 +1487,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,
@@ -1469,13 +1607,12 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
                 formula: goal,
                 justification: 'Eliminacion de disyuncion (prueba por casos)',
                 premises: [disjStepNum, leftGoalStep, rightGoalStep],
+                subproofs: [subProofL, subProofR],
             });
-            return {
-                goal,
-                steps: mainSteps,
-                status: 'complete',
-                derivedFrom: premiseNames,
-            };
+            return buildProof(goal, mainSteps, premiseNames, theory, 'natural_deduction', [
+                subProofL,
+                subProofR,
+            ]);
         }
     }
     // Fallback: verificar semánticamente
@@ -1547,12 +1684,7 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
                 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 +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 {
@@ -1779,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`,
@@ -1915,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 };