@stevenvo780/st-lang 3.0.1 → 3.1.0

package/dist/profiles/classical/propositional.js

@@ -704,7 +704,7 @@ function addDerivedFormula(state, formula, justification, premises) {
     state.known.set(hash, formula);
     return true;
 }
-function tryDerive(goal, theory, premiseNames) {
+function tryDerive(goal, theory, premiseNames, depth = 0) {
     const state = {
         known: new Map(),
         steps: [],
@@ -781,9 +781,10 @@ function tryDerive(goal, theory, premiseNames) {
                         ]) || changed;
                 }
                 // Conjunction Introduction: de A y B, derivar A & B
+                // Only produce conjunctions that are relevant to the goal to avoid O(n²) explosion
                 if (f1 !== f2) {
                     const conj = { kind: 'and', args: [f1, f2] };
-                    if (formulasEqual(conj, goal)) {
+                    if (formulasEqual(conj, goal) || isRelevantToGoal(conj, goal)) {
                         changed =
                             addDerivedFormula(state, conj, 'Introduccion de conjuncion', [
                                 findStep(state.steps, f1),
@@ -909,6 +910,33 @@ 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);
+                        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] &&
@@ -947,7 +975,8 @@ function tryDerive(goal, theory, premiseNames) {
                         ]) || changed;
                 }
             }
-            // Disjunction Introduction: de A, derivar A | B (si A|B es la meta)
+            // 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]) {
                 if (formulasEqual(f1, goal.args[0]) || formulasEqual(f1, goal.args[1])) {
                     changed =
@@ -956,6 +985,23 @@ function tryDerive(goal, theory, premiseNames) {
                         ]) || changed;
                 }
             }
+            // Also check if f1 can form a disjunction relevant to some intermediate goal
+            if (goal.kind !== 'or') {
+                // If the goal is e.g. (A|B) -> C, and we have A, generate A|B as intermediate
+                const checkDisjGoals = (g) => {
+                    if (g.kind === 'or' && g.args?.[0] && g.args?.[1]) {
+                        if (formulasEqual(f1, g.args[0]) || formulasEqual(f1, g.args[1])) {
+                            const disj = { kind: 'or', args: [g.args[0], g.args[1]] };
+                            changed =
+                                addDerivedFormula(state, disj, 'Introduccion de disyuncion', [
+                                    findStep(state.steps, f1),
+                                ]) || changed;
+                        }
+                    }
+                    g.args?.forEach(checkDisjGoals);
+                };
+                checkDisjGoals(goal);
+            }
             // Double Negation Elimination: de !!A, derivar A
             if (f1.kind === 'not' && f1.args?.[0]?.kind === 'not' && f1.args[0].args?.[0]) {
                 const inner = f1.args[0].args[0];
@@ -970,13 +1016,14 @@ function tryDerive(goal, theory, premiseNames) {
                         findStep(state.steps, f1),
                     ]) || changed;
             }
-            // Introducción de implicación simple: si la meta es A -> B y ya conocemos B, se permite cerrar
+            // Weakening (Debilitamiento): si la meta es A -> B y ya conocemos B,
+            // entonces A -> B es válida (B ⊢ A -> B en lógica clásica).
             if (goal.kind === 'implies' &&
                 goal.args?.[0] &&
                 goal.args?.[1] &&
                 formulasEqual(goal.args[1], f1)) {
                 changed =
-                    addDerivedFormula(state, goal, 'Introduccion de implicacion', [
+                    addDerivedFormula(state, goal, 'Debilitamiento (B ⊢ A → B)', [
                         findStep(state.steps, f1),
                     ]) || changed;
             }
@@ -1081,6 +1128,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]) {
@@ -1135,6 +1258,226 @@ function tryDerive(goal, theory, premiseNames) {
             derivedFrom: premiseNames,
         };
     }
+    // --- 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 subStepOffset = stepNum;
+                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],
+                });
+                return {
+                    goal,
+                    steps: mainSteps,
+                    status: 'complete',
+                    derivedFrom: premiseNames,
+                };
+            }
+        }
+    }
+    // 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];
+            // 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],
+            });
+            return {
+                goal,
+                steps: mainSteps,
+                status: 'complete',
+                derivedFrom: premiseNames,
+            };
+        }
+    }
     // Fallback: verificar semánticamente
     const allAxiomFormulas = premiseNames
         .map((n) => theory.axioms.get(n) || theory.theorems.get(n))
@@ -1145,6 +1488,7 @@ function tryDerive(goal, theory, premiseNames) {
             collectAtoms(f).forEach((a) => atoms.add(a));
         collectAtoms(goal).forEach((a) => atoms.add(a));
         const atomList = Array.from(atoms).sort();
+        let semanticResult;
         // Fast path: bitset semantic check
         const allPure = allAxiomFormulas.every(isPurePropositional) && isPurePropositional(goal);
         if (allPure && atomList.length <= 26) {
@@ -1157,19 +1501,10 @@ function tryDerive(goal, theory, premiseNames) {
                 premisesConj = bvAnd(premisesConj, pb);
             // Valid if: wherever premises are true, goal is also true
             // i.e., premisesConj & ~goalBits === 0
-            if (bvIsZero(bvAnd(premisesConj, bvNot(goalBits, allOnes)))) {
-                return {
-                    goal,
-                    steps: state.steps,
-                    status: 'complete',
-                    derivedFrom: premiseNames,
-                };
-            }
+            semanticResult = bvIsZero(bvAnd(premisesConj, bvNot(goalBits, allOnes)));
         }
         else if (allPure && atomList.length > 26) {
             // DPLL fallback for >26 atoms
-            // Build: (premise1 & premise2 & ... & premiseN) -> goal
-            // Valid iff NOT satisfiable: (premises & !goal)
             let conjunction = allAxiomFormulas[0];
             for (let i = 1; i < allAxiomFormulas.length; i++) {
                 conjunction = { kind: 'and', args: [conjunction, allAxiomFormulas[i]] };
@@ -1177,34 +1512,47 @@ function tryDerive(goal, theory, premiseNames) {
             const negGoal = { kind: 'not', args: [goal] };
             const check = { kind: 'and', args: [conjunction, negGoal] };
             const result = (0, dpll_1.dpll)(check);
-            if (!result.satisfiable) {
-                return {
-                    goal,
-                    steps: state.steps,
-                    status: 'complete',
-                    derivedFrom: premiseNames,
-                };
-            }
+            semanticResult = !result.satisfiable;
         }
         else {
             // Classic fallback
             const valuations = generateValuations(atomList);
-            let semanticallyValid = true;
+            semanticResult = true;
             for (const v of valuations) {
                 const premisesTrue = allAxiomFormulas.every((f) => evaluateClassical(f, v));
                 if (premisesTrue && !evaluateClassical(goal, v)) {
-                    semanticallyValid = false;
+                    semanticResult = false;
                     break;
                 }
             }
-            if (semanticallyValid) {
-                return {
-                    goal,
-                    steps: state.steps,
-                    status: 'complete',
-                    derivedFrom: premiseNames,
-                };
+        }
+        if (semanticResult) {
+            // Generate a synthetic final proof step so the user sees a complete derivation
+            // instead of just "derivado exitosamente" with no proof trace.
+            const goalHash = formulaHash(goal);
+            if (!state.known.has(goalHash)) {
+                const premiseStepNums = premiseNames
+                    .map((n) => {
+                    const f = theory.axioms.get(n) || theory.theorems.get(n);
+                    return f ? findStep(state.steps, f) : 0;
+                })
+                    .filter((n) => n > 0);
+                state.stepCount++;
+                state.steps.push({
+                    stepNumber: state.stepCount,
+                    formula: goal,
+                    justification: 'Verificacion semantica (todas las valuaciones satisfacen la consecuencia)',
+                    premises: premiseStepNums,
+                });
+                state.known.set(goalHash, goal);
             }
+            const relevantSteps = traceBack(state.steps, goal);
+            return {
+                goal,
+                steps: relevantSteps,
+                status: 'complete',
+                derivedFrom: premiseNames,
+            };
         }
     }
     return null;