@stevenvo780/st-lang 3.1.1 → 3.1.3

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':
@@ -106,11 +110,14 @@ function* generateValuationsLazy(atoms) {
         yield {};
         return;
     }
-    const total = 1 << n;
+    if (n > 23)
+        throw new Error('Demasiadas variables para tabla de verdad (>23)');
+    const total = 2 ** n;
     for (let i = 0; i < total; i++) {
         const v = {};
         for (let j = 0; j < n; j++) {
-            v[atoms[j]] = Boolean((i >> (n - 1 - j)) & 1);
+            const divisor = 2 ** (n - 1 - j);
+            v[atoms[j]] = Math.floor(i / divisor) % 2 === 1;
         }
         yield v;
     }
@@ -311,6 +318,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 +436,8 @@ function computeNNF(f) {
         const args = node.args || [];
         if (!negated) {
             switch (k) {
+                case 'true':
+                case 'false':
                 case 'atom':
                 case 'predicate':
                     return node;
@@ -468,6 +481,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 +654,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 +794,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,6 +804,7 @@ function addDerivedFormula(state, formula, justification, premises) {
         formula,
         justification,
         premises,
+        source,
     });
     state.known.set(hash, formula);
     return true;
@@ -809,6 +914,7 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
                 formula: f,
                 justification: `Premisa (${name})`,
                 premises: [],
+                source: 'premise',
             });
             state.known.set(formulaHash(f), f);
         }
@@ -1423,14 +1529,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: [] });
                     }
@@ -1443,17 +1549,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 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;
@@ -1466,6 +1573,7 @@ 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
@@ -1477,6 +1585,7 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
                     justification: 'Prueba Condicional (Teorema de Deduccion)',
                     premises: [assumptionStepNum, subGoalStepNum],
                     subproofs: [subProof],
+                    source: 'rule',
                 });
                 return buildProof(goal, mainSteps, premiseNames, theory, 'natural_deduction', [subProof]);
             }
@@ -1505,7 +1614,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
@@ -1522,7 +1631,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
@@ -1530,7 +1639,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: [] });
                 }
@@ -1544,15 +1653,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;
@@ -1565,6 +1675,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;
@@ -1576,15 +1687,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;
@@ -1597,6 +1709,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;
@@ -1608,6 +1721,7 @@ function tryDerive(goal, theory, premiseNames, depth = 0) {
                 justification: 'Eliminacion de disyuncion (prueba por casos)',
                 premises: [disjStepNum, leftGoalStep, rightGoalStep],
                 subproofs: [subProofL, subProofR],
+                source: 'rule',
             });
             return buildProof(goal, mainSteps, premiseNames, theory, 'natural_deduction', [
                 subProofL,
@@ -1680,6 +1794,7 @@ 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);
             }
@@ -1904,26 +2019,56 @@ 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) => theory.axioms.get(n) || theory.theorems.get(n))
+            .map((n) => effectiveTheory.axioms.get(n) || effectiveTheory.theorems.get(n))
             .filter((f) => f !== undefined);
         let semanticResult;
         const atoms = new Set();
@@ -1980,42 +2125,46 @@ class ClassicalPropositional {
             }
         }
         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 = [
-                ...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),
+                ...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, theory, 'semantic');
+            const semanticProof = buildProof(goal, semanticProofSteps, premiseNames, effectiveTheory, 'semantic');
             return {
                 status: 'provable',
-                output: `${formulaToString(goal)} es DEMOSTRABLE desde la teoria`,
+                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: [],
+                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,
         };
     }
@@ -2029,14 +2178,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')
@@ -2057,8 +2209,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,