@stevenvo780/autologic 1.0.0 → 2.0.0

package/dist/formula/argument-builder.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCrossSentenceDerivations = buildCrossSentenceDerivations;
+const connectors_1 = require("./connectors");
+const coreference_1 = require("../atoms/coreference");
+const keyword_extractor_1 = require("../atoms/keyword-extractor");
+/**
+ * Enriquece las fórmulas per-sentence con derivaciones cross-sentence.
+ */
+function buildCrossSentenceDerivations(perSentenceFormulas, sentences, atomEntries, detectedPatterns) {
+    const extra = [];
+    let labelCounter = perSentenceFormulas.length + 1;
+    // Clasificar fórmulas existentes
+    const conditionals = perSentenceFormulas.filter(f => f.stType === 'axiom' && f.formula.includes(connectors_1.ST_OPERATORS.implication));
+    const simpleAxioms = perSentenceFormulas.filter(f => f.stType === 'axiom' && !f.formula.includes(connectors_1.ST_OPERATORS.implication) &&
+        !f.formula.includes(connectors_1.ST_OPERATORS.biconditional));
+    const negationAxioms = simpleAxioms.filter(f => f.formula.startsWith('!') || f.formula.startsWith('!('));
+    const positiveAxioms = simpleAxioms.filter(f => !f.formula.startsWith('!') && !f.formula.startsWith('!('));
+    const disjunctions = perSentenceFormulas.filter(f => f.stType === 'axiom' && f.formula.includes(connectors_1.ST_OPERATORS.disjunction)
+        && !f.formula.includes(connectors_1.ST_OPERATORS.implication));
+    const existingDerives = perSentenceFormulas.filter(f => f.stType === 'derive');
+    // Si ya hay derives, no duplicar
+    if (existingDerives.length > 0)
+        return extra;
+    // ── Modus Ponens: A→B, A ⊢ B ──────────────────
+    if (detectedPatterns.includes('modus_ponens') || conditionals.length > 0) {
+        for (const cond of conditionals) {
+            const parsed = parseImplication(cond.formula);
+            if (!parsed)
+                continue;
+            // Buscar un axioma que unifique con el antecedente
+            const matchingPremise = findMatchingAxiom(parsed.antecedent, positiveAxioms, atomEntries);
+            if (matchingPremise) {
+                // Buscar si ya hay conclusión explícita
+                const conclusionSentences = sentences.filter(s => s.clauses.some(c => c.role === 'conclusion'));
+                extra.push({
+                    formula: parsed.consequent,
+                    stType: 'derive',
+                    label: `mp_${labelCounter++}`,
+                    sourceText: `Modus Ponens: de ${cond.label} y ${matchingPremise.label}`,
+                    sourceSentence: cond.sourceSentence,
+                    comment: `Modus Ponens: ${parsed.antecedent} → ${parsed.consequent}, ${parsed.antecedent} ⊢ ${parsed.consequent}`,
+                });
+                // Solo una derivación MP por condicional
+                break;
+            }
+        }
+    }
+    // ── Modus Tollens: A→B, ¬B ⊢ ¬A ──────────────
+    if (detectedPatterns.includes('modus_tollens') ||
+        (conditionals.length > 0 && negationAxioms.length > 0)) {
+        for (const cond of conditionals) {
+            const parsed = parseImplication(cond.formula);
+            if (!parsed)
+                continue;
+            // Buscar ¬B entre los axiomas de negación
+            const negConsequent = stripNegation(parsed.consequent);
+            if (!negConsequent)
+                continue;
+            const matchingNeg = negationAxioms.find(a => {
+                const stripped = stripNegation(a.formula);
+                return stripped !== null && atomsUnify(stripped, parsed.consequent, atomEntries);
+            });
+            // También buscar si el axioma negado es directamente ¬(consequent)
+            const matchingNeg2 = negationAxioms.find(a => {
+                const innerAtom = extractNegatedAtom(a.formula);
+                return innerAtom !== null && atomsUnify(innerAtom, parsed.consequent, atomEntries);
+            });
+            const foundNeg = matchingNeg || matchingNeg2;
+            if (foundNeg) {
+                extra.push({
+                    formula: `${connectors_1.ST_OPERATORS.negation}(${parsed.antecedent})`,
+                    stType: 'derive',
+                    label: `mt_${labelCounter++}`,
+                    sourceText: `Modus Tollens: de ${cond.label} y ${foundNeg.label}`,
+                    sourceSentence: cond.sourceSentence,
+                    comment: `Modus Tollens: ${parsed.antecedent}→${parsed.consequent}, ¬${parsed.consequent} ⊢ ¬${parsed.antecedent}`,
+                });
+                break;
+            }
+        }
+    }
+    // ── Silogismo Hipotético: A→B, B→C ⊢ A→C ─────
+    if (detectedPatterns.includes('hypothetical_syllogism') || conditionals.length >= 2) {
+        const chains = findConditionalChains(conditionals, atomEntries);
+        for (const chain of chains) {
+            extra.push({
+                formula: `${chain.start} ${connectors_1.ST_OPERATORS.implication} ${chain.end}`,
+                stType: 'derive',
+                label: `hs_${labelCounter++}`,
+                sourceText: `Silogismo Hipotético: cadena de ${chain.labels.join(', ')}`,
+                sourceSentence: conditionals[0].sourceSentence,
+                comment: `Silogismo Hipotético: ${chain.start} → ... → ${chain.end}`,
+            });
+        }
+    }
+    // ── Silogismo Disyuntivo: A∨B, ¬A ⊢ B ────────
+    if (detectedPatterns.includes('disjunctive_syllogism') ||
+        (disjunctions.length > 0 && negationAxioms.length > 0)) {
+        for (const disj of disjunctions) {
+            const parts = disj.formula.split(` ${connectors_1.ST_OPERATORS.disjunction} `).map(s => s.trim());
+            if (parts.length < 2)
+                continue;
+            for (const negAxiom of negationAxioms) {
+                const negated = extractNegatedAtom(negAxiom.formula);
+                if (!negated)
+                    continue;
+                const negIdx = parts.findIndex(p => atomsUnify(p, negated, atomEntries));
+                if (negIdx >= 0) {
+                    const remaining = parts.filter((_, i) => i !== negIdx).join(` ${connectors_1.ST_OPERATORS.disjunction} `);
+                    extra.push({
+                        formula: remaining,
+                        stType: 'derive',
+                        label: `ds_${labelCounter++}`,
+                        sourceText: `Silogismo Disyuntivo: de ${disj.label} y ${negAxiom.label}`,
+                        sourceSentence: disj.sourceSentence,
+                        comment: `Silogismo Disyuntivo: ${disj.formula}, ${negAxiom.formula} ⊢ ${remaining}`,
+                    });
+                    break;
+                }
+            }
+        }
+    }
+    // ── Cadena condicional con MP final ────────────
+    // Si tenemos A→B, B→C, C→D y además A, derivar D
+    if (conditionals.length >= 2 && positiveAxioms.length > 0) {
+        const chains = findConditionalChains(conditionals, atomEntries);
+        for (const chain of chains) {
+            const matchingStart = findMatchingAxiom(chain.start, positiveAxioms, atomEntries);
+            if (matchingStart && extra.every(e => e.formula !== chain.end)) {
+                extra.push({
+                    formula: chain.end,
+                    stType: 'derive',
+                    label: `chain_${labelCounter++}`,
+                    sourceText: `Cadena + MP: de ${chain.labels.join(', ')} y ${matchingStart.label}`,
+                    sourceSentence: conditionals[conditionals.length - 1].sourceSentence,
+                    comment: `Cadena condicional + Modus Ponens: ${chain.start} → ... → ${chain.end}, ${chain.start} ⊢ ${chain.end}`,
+                });
+            }
+        }
+    }
+    return extra;
+}
+// ══════════════════════════════════════════════════════════════
+// Utilidades internas
+// ══════════════════════════════════════════════════════════════
+/** Parsea "A -> B" en { antecedent, consequent } */
+function parseImplication(formula) {
+    const idx = formula.indexOf(` ${connectors_1.ST_OPERATORS.implication} `);
+    if (idx < 0)
+        return null;
+    const antecedent = formula.slice(0, idx).trim();
+    const consequent = formula.slice(idx + ` ${connectors_1.ST_OPERATORS.implication} `.length).trim();
+    if (!antecedent || !consequent)
+        return null;
+    return { antecedent, consequent };
+}
+/** Extrae el átomo dentro de una negación: "!(X)" → "X", "!X" → "X" */
+function extractNegatedAtom(formula) {
+    const trimmed = formula.trim();
+    // "!(ATOM)" pattern
+    const match1 = trimmed.match(/^!\((.+)\)$/);
+    if (match1)
+        return match1[1].trim();
+    // "!ATOM" pattern
+    const match2 = trimmed.match(/^!(\w+)$/);
+    if (match2)
+        return match2[1].trim();
+    return null;
+}
+/** Remueve negación si existe, retorna null si no es negación */
+function stripNegation(formula) {
+    const inner = extractNegatedAtom(formula);
+    return inner;
+}
+/**
+ * Verifica si dos expresiones atómicas se "unifican" (son el mismo concepto).
+ * Usa similitud de stems para manejar variaciones morfológicas.
+ */
+function atomsUnify(a, b, atomEntries) {
+    // Igualdad directa
+    if (a === b)
+        return true;
+    // Normalizar quitando paréntesis externos
+    const na = a.replace(/^\(|\)$/g, '').trim();
+    const nb = b.replace(/^\(|\)$/g, '').trim();
+    if (na === nb)
+        return true;
+    // Buscar los textos originales de los átomos
+    const textA = atomEntries.find(e => e.id === na)?.text;
+    const textB = atomEntries.find(e => e.id === nb)?.text;
+    if (textA && textB) {
+        const stemsA = (0, keyword_extractor_1.bagOfStems)(textA, 'es');
+        const stemsB = (0, keyword_extractor_1.bagOfStems)(textB, 'es');
+        return (0, coreference_1.diceSimilarity)(stemsA, stemsB) >= 0.5;
+    }
+    return false;
+}
+/**
+ * Busca un axioma simple que unifique con un átomo/fórmula dado.
+ */
+function findMatchingAxiom(target, axioms, atomEntries) {
+    // Match exacto primero
+    const exact = axioms.find(a => a.formula === target);
+    if (exact)
+        return exact;
+    // Match por unificación
+    for (const axiom of axioms) {
+        if (atomsUnify(axiom.formula, target, atomEntries)) {
+            return axiom;
+        }
+    }
+    return null;
+}
+/**
+ * Encuentra cadenas de condicionales: A→B, B→C → chain(A, C)
+ */
+function findConditionalChains(conditionals, atomEntries) {
+    const parsed = conditionals
+        .map(c => ({ ...parseImplication(c.formula), label: c.label }))
+        .filter(p => p.antecedent && p.consequent);
+    if (parsed.length < 2)
+        return [];
+    const chains = [];
+    // Buscar cadenas empezando por cada condicional
+    for (let i = 0; i < parsed.length; i++) {
+        let current = parsed[i];
+        const chain = [current.label];
+        let end = current.consequent;
+        for (let j = 0; j < parsed.length; j++) {
+            if (j === i || chain.includes(parsed[j].label))
+                continue;
+            if (atomsUnify(end, parsed[j].antecedent, atomEntries)) {
+                chain.push(parsed[j].label);
+                end = parsed[j].consequent;
+                j = -1; // restart search for next link
+            }
+        }
+        if (chain.length >= 2) {
+            chains.push({
+                start: parsed[i].antecedent,
+                end,
+                labels: chain,
+            });
+        }
+    }
+    // Deduplicar: quedarse con la cadena más larga para cada par start→end
+    const seen = new Set();
+    return chains
+        .sort((a, b) => b.labels.length - a.labels.length)
+        .filter(c => {
+        const key = `${c.start}->${c.end}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+//# sourceMappingURL=argument-builder.js.map

package/dist/formula/argument-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"argument-builder.js","sourceRoot":"","sources":["../../src/formula/argument-builder.ts"],"names":[],"mappings":"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"}

package/dist/formula/index.d.ts

@@ -1,15 +1,21 @@
 /**
  * Formula — Orquestador de construcción de fórmulas
+ *
+ * Pipeline:
+ * 1. Construir fórmulas per-sentence (según perfil lógico)
+ * 2. Enriquecer con derivaciones cross-sentence (argument-builder)
  */
 export { buildPropositional } from './propositional';
 export { buildFirstOrder } from './first-order';
 export { buildModal } from './modal';
 export { buildTemporal } from './temporal';
+export { buildCrossSentenceDerivations } from './argument-builder';
 export { roleToOperator, profileSupportsOperator, ST_OPERATORS } from './connectors';
 import type { AnalyzedSentence, AtomEntry, FormulaEntry, LogicProfile } from '../types';
 /**
  * Construye fórmulas ST según el perfil lógico seleccionado.
- * Delega al builder específico del perfil.
+ * Delega al builder específico del perfil, luego enriquece
+ * con derivaciones cross-sentence.
  */
 export declare function buildFormulas(sentences: AnalyzedSentence[], atomEntries: AtomEntry[], profile: LogicProfile, detectedPatterns: string[]): FormulaEntry[];
 //# sourceMappingURL=index.d.ts.map

package/dist/formula/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/formula/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,uBAAuB,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAErF,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAMxF;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,gBAAgB,EAAE,EAC7B,WAAW,EAAE,SAAS,EAAE,EACxB,OAAO,EAAE,YAAY,EACrB,gBAAgB,EAAE,MAAM,EAAE,GACzB,YAAY,EAAE,CAwBhB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/formula/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,6BAA6B,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,EAAE,cAAc,EAAE,uBAAuB,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAErF,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAOxF;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,gBAAgB,EAAE,EAC7B,WAAW,EAAE,SAAS,EAAE,EACxB,OAAO,EAAE,YAAY,EACrB,gBAAgB,EAAE,MAAM,EAAE,GACzB,YAAY,EAAE,CA0ChB"}

package/dist/formula/index.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ST_OPERATORS = exports.profileSupportsOperator = exports.roleToOperator = exports.buildTemporal = exports.buildModal = exports.buildFirstOrder = exports.buildPropositional = void 0;
+exports.ST_OPERATORS = exports.profileSupportsOperator = exports.roleToOperator = exports.buildCrossSentenceDerivations = exports.buildTemporal = exports.buildModal = exports.buildFirstOrder = exports.buildPropositional = void 0;
 exports.buildFormulas = buildFormulas;
 /**
  * Formula — Orquestador de construcción de fórmulas
+ *
+ * Pipeline:
+ * 1. Construir fórmulas per-sentence (según perfil lógico)
+ * 2. Enriquecer con derivaciones cross-sentence (argument-builder)
  */
 var propositional_1 = require("./propositional");
 Object.defineProperty(exports, "buildPropositional", { enumerable: true, get: function () { return propositional_1.buildPropositional; } });
@@ -13,6 +17,8 @@ var modal_1 = require("./modal");
 Object.defineProperty(exports, "buildModal", { enumerable: true, get: function () { return modal_1.buildModal; } });
 var temporal_1 = require("./temporal");
 Object.defineProperty(exports, "buildTemporal", { enumerable: true, get: function () { return temporal_1.buildTemporal; } });
+var argument_builder_1 = require("./argument-builder");
+Object.defineProperty(exports, "buildCrossSentenceDerivations", { enumerable: true, get: function () { return argument_builder_1.buildCrossSentenceDerivations; } });
 var connectors_1 = require("./connectors");
 Object.defineProperty(exports, "roleToOperator", { enumerable: true, get: function () { return connectors_1.roleToOperator; } });
 Object.defineProperty(exports, "profileSupportsOperator", { enumerable: true, get: function () { return connectors_1.profileSupportsOperator; } });
@@ -21,29 +27,41 @@ const propositional_2 = require("./propositional");
 const first_order_2 = require("./first-order");
 const modal_2 = require("./modal");
 const temporal_2 = require("./temporal");
+const argument_builder_2 = require("./argument-builder");
 /**
  * Construye fórmulas ST según el perfil lógico seleccionado.
- * Delega al builder específico del perfil.
+ * Delega al builder específico del perfil, luego enriquece
+ * con derivaciones cross-sentence.
  */
 function buildFormulas(sentences, atomEntries, profile, detectedPatterns) {
+    // ── Paso 1: fórmulas per-sentence ─────────────
+    let perSentence;
     switch (profile) {
         case 'classical.propositional':
         case 'intuitionistic.propositional':
         case 'paraconsistent.belnap':
         case 'arithmetic':
         case 'probabilistic.basic':
-            return (0, propositional_2.buildPropositional)(sentences, atomEntries, detectedPatterns);
+            perSentence = (0, propositional_2.buildPropositional)(sentences, atomEntries, detectedPatterns);
+            break;
         case 'classical.first_order':
         case 'aristotelian.syllogistic':
-            return (0, first_order_2.buildFirstOrder)(sentences, atomEntries, detectedPatterns);
+            perSentence = (0, first_order_2.buildFirstOrder)(sentences, atomEntries, detectedPatterns);
+            break;
         case 'modal.k':
         case 'epistemic.s5':
         case 'deontic.standard':
-            return (0, modal_2.buildModal)(sentences, atomEntries, profile);
+            perSentence = (0, modal_2.buildModal)(sentences, atomEntries, profile);
+            break;
         case 'temporal.ltl':
-            return (0, temporal_2.buildTemporal)(sentences, atomEntries);
+            perSentence = (0, temporal_2.buildTemporal)(sentences, atomEntries);
+            break;
         default:
-            return (0, propositional_2.buildPropositional)(sentences, atomEntries, detectedPatterns);
+            perSentence = (0, propositional_2.buildPropositional)(sentences, atomEntries, detectedPatterns);
+            break;
     }
+    // ── Paso 2: derivaciones cross-sentence ───────
+    const crossDerives = (0, argument_builder_2.buildCrossSentenceDerivations)(perSentence, sentences, atomEntries, detectedPatterns);
+    return [...perSentence, ...crossDerives];
 }
 //# sourceMappingURL=index.js.map

package/dist/formula/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/formula/index.ts"],"names":[],"mappings":";;;AAmBA,sCA6BC;AAhDD;;GAEG;AACH,iDAAqD;AAA5C,mHAAA,kBAAkB,OAAA;AAC3B,6CAAgD;AAAvC,8GAAA,eAAe,OAAA;AACxB,iCAAqC;AAA5B,mGAAA,UAAU,OAAA;AACnB,uCAA2C;AAAlC,yGAAA,aAAa,OAAA;AACtB,2CAAqF;AAA5E,4GAAA,cAAc,OAAA;AAAE,qHAAA,uBAAuB,OAAA;AAAE,0GAAA,YAAY,OAAA;AAG9D,mDAAqD;AACrD,+CAAgD;AAChD,mCAAqC;AACrC,yCAA2C;AAE3C;;;GAGG;AACH,SAAgB,aAAa,CAC3B,SAA6B,EAC7B,WAAwB,EACxB,OAAqB,EACrB,gBAA0B;IAE1B,QAAQ,OAAO,EAAE,CAAC;QAChB,KAAK,yBAAyB,CAAC;QAC/B,KAAK,8BAA8B,CAAC;QACpC,KAAK,uBAAuB,CAAC;QAC7B,KAAK,YAAY,CAAC;QAClB,KAAK,qBAAqB;YACxB,OAAO,IAAA,kCAAkB,EAAC,SAAS,EAAE,WAAW,EAAE,gBAAgB,CAAC,CAAC;QAEtE,KAAK,uBAAuB,CAAC;QAC7B,KAAK,0BAA0B;YAC7B,OAAO,IAAA,6BAAe,EAAC,SAAS,EAAE,WAAW,EAAE,gBAAgB,CAAC,CAAC;QAEnE,KAAK,SAAS,CAAC;QACf,KAAK,cAAc,CAAC;QACpB,KAAK,kBAAkB;YACrB,OAAO,IAAA,kBAAU,EAAC,SAAS,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;QAErD,KAAK,cAAc;YACjB,OAAO,IAAA,wBAAa,EAAC,SAAS,EAAE,WAAW,CAAC,CAAC;QAE/C;YACE,OAAO,IAAA,kCAAkB,EAAC,SAAS,EAAE,WAAW,EAAE,gBAAgB,CAAC,CAAC;IACxE,CAAC;AACH,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/formula/index.ts"],"names":[],"mappings":";;;AA0BA,sCA+CC;AAzED;;;;;;GAMG;AACH,iDAAqD;AAA5C,mHAAA,kBAAkB,OAAA;AAC3B,6CAAgD;AAAvC,8GAAA,eAAe,OAAA;AACxB,iCAAqC;AAA5B,mGAAA,UAAU,OAAA;AACnB,uCAA2C;AAAlC,yGAAA,aAAa,OAAA;AACtB,uDAAmE;AAA1D,iIAAA,6BAA6B,OAAA;AACtC,2CAAqF;AAA5E,4GAAA,cAAc,OAAA;AAAE,qHAAA,uBAAuB,OAAA;AAAE,0GAAA,YAAY,OAAA;AAG9D,mDAAqD;AACrD,+CAAgD;AAChD,mCAAqC;AACrC,yCAA2C;AAC3C,yDAAmE;AAEnE;;;;GAIG;AACH,SAAgB,aAAa,CAC3B,SAA6B,EAC7B,WAAwB,EACxB,OAAqB,EACrB,gBAA0B;IAE1B,iDAAiD;IACjD,IAAI,WAA2B,CAAC;IAEhC,QAAQ,OAAO,EAAE,CAAC;QAChB,KAAK,yBAAyB,CAAC;QAC/B,KAAK,8BAA8B,CAAC;QACpC,KAAK,uBAAuB,CAAC;QAC7B,KAAK,YAAY,CAAC;QAClB,KAAK,qBAAqB;YACxB,WAAW,GAAG,IAAA,kCAAkB,EAAC,SAAS,EAAE,WAAW,EAAE,gBAAgB,CAAC,CAAC;YAC3E,MAAM;QAER,KAAK,uBAAuB,CAAC;QAC7B,KAAK,0BAA0B;YAC7B,WAAW,GAAG,IAAA,6BAAe,EAAC,SAAS,EAAE,WAAW,EAAE,gBAAgB,CAAC,CAAC;YACxE,MAAM;QAER,KAAK,SAAS,CAAC;QACf,KAAK,cAAc,CAAC;QACpB,KAAK,kBAAkB;YACrB,WAAW,GAAG,IAAA,kBAAU,EAAC,SAAS,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;YAC1D,MAAM;QAER,KAAK,cAAc;YACjB,WAAW,GAAG,IAAA,wBAAa,EAAC,SAAS,EAAE,WAAW,CAAC,CAAC;YACpD,MAAM;QAER;YACE,WAAW,GAAG,IAAA,kCAAkB,EAAC,SAAS,EAAE,WAAW,EAAE,gBAAgB,CAAC,CAAC;YAC3E,MAAM;IACV,CAAC;IAED,iDAAiD;IACjD,MAAM,YAAY,GAAG,IAAA,gDAA6B,EAChD,WAAW,EACX,SAAS,EACT,WAAW,EACX,gBAAgB,CACjB,CAAC;IAEF,OAAO,CAAC,GAAG,WAAW,EAAE,GAAG,YAAY,CAAC,CAAC;AAC3C,CAAC"}

package/dist/formula/propositional.d.ts

@@ -2,10 +2,12 @@
  * Propositional Formula Builder
  *
  * Construye fórmulas de lógica proposicional a partir de átomos con roles.
+ * Genera fórmulas reales con conectivos: →, ∧, ∨, ¬, ↔
  */
 import type { AnalyzedSentence, AtomEntry, FormulaEntry } from '../types';
 /**
  * Construye fórmulas proposicionales para un conjunto de oraciones.
+ * Cada oración se procesa según su tipo detectado.
  */
 export declare function buildPropositional(sentences: AnalyzedSentence[], atomEntries: AtomEntry[], detectedPatterns: string[]): FormulaEntry[];
 //# sourceMappingURL=propositional.d.ts.map

package/dist/formula/propositional.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"propositional.d.ts","sourceRoot":"","sources":["../../src/formula/propositional.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,YAAY,EAAmB,MAAM,UAAU,CAAC;AAG3F;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,WAAW,EAAE,SAAS,EAAE,EACxB,gBAAgB,EAAE,MAAM,EAAE,GACzB,YAAY,EAAE,CAmBhB"}
+{"version":3,"file":"propositional.d.ts","sourceRoot":"","sources":["../../src/formula/propositional.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,YAAY,EAAmB,MAAM,UAAU,CAAC;AAG3F;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,gBAAgB,EAAE,EAC7B,WAAW,EAAE,SAAS,EAAE,EACxB,gBAAgB,EAAE,MAAM,EAAE,GACzB,YAAY,EAAE,CAiBhB"}

package/dist/formula/propositional.js

@@ -4,56 +4,68 @@ exports.buildPropositional = buildPropositional;
 const connectors_1 = require("./connectors");
 /**
  * Construye fórmulas proposicionales para un conjunto de oraciones.
+ * Cada oración se procesa según su tipo detectado.
  */
 function buildPropositional(sentences, atomEntries, detectedPatterns) {
     const formulas = [];
     let labelCounter = 1;
+    // Construir mapa global de cláusula-texto → atomId
+    const globalClauseAtomMap = buildGlobalAtomMap(sentences, atomEntries);
     for (let sIdx = 0; sIdx < sentences.length; sIdx++) {
         const sentence = sentences[sIdx];
-        const sentenceAtoms = atomEntries.filter(a => {
-            // Buscar átomos que pertenecen a cláusulas de esta oración
-            const clauseIdxs = sentence.clauses.map((_, i) => i);
-            // Heurística: mapear por índice global de cláusula
-            return true; // procesamos todos y filtramos por contexto
-        });
-        const builtFormulas = buildSentenceFormulas(sentence, atomEntries, sIdx, labelCounter, detectedPatterns);
+        const builtFormulas = buildSentenceFormulas(sentence, atomEntries, globalClauseAtomMap, sIdx, labelCounter, detectedPatterns);
         formulas.push(...builtFormulas);
         labelCounter += builtFormulas.length;
     }
     return formulas;
 }
+/**
+ * Construye un mapa global de texto-cláusula → atomId.
+ */
+function buildGlobalAtomMap(sentences, atomEntries) {
+    const map = new Map();
+    // Recopilar todas las cláusulas con su índice global
+    let globalIdx = 0;
+    for (const sentence of sentences) {
+        for (const clause of sentence.clauses) {
+            // Buscar átomo por texto exacto
+            const exactMatch = atomEntries.find(a => a.text === clause.text);
+            if (exactMatch) {
+                map.set(clause.text, exactMatch.id);
+            }
+            else {
+                // Buscar por inclusión
+                const partialMatch = atomEntries.find(a => a.text.includes(clause.text) || clause.text.includes(a.text));
+                if (partialMatch) {
+                    map.set(clause.text, partialMatch.id);
+                }
+                else {
+                    // Buscar por índice de cláusula fuente
+                    const bySource = atomEntries.find(a => a.sourceClause === globalIdx);
+                    if (bySource) {
+                        map.set(clause.text, bySource.id);
+                    }
+                }
+            }
+            globalIdx++;
+        }
+    }
+    return map;
+}
 /**
  * Construye fórmulas para una oración individual.
  */
-function buildSentenceFormulas(sentence, allAtoms, sentenceIdx, labelStart, patterns) {
+function buildSentenceFormulas(sentence, allAtoms, globalMap, sentenceIdx, labelStart, patterns) {
     const clauses = sentence.clauses;
     if (clauses.length === 0)
         return [];
-    // Obtener átomos para esta oración (por texto de cláusula)
-    const clauseAtomMap = new Map();
-    for (const atom of allAtoms) {
-        // Mapear texto de cláusula → atom ID
-        const matchClause = clauses.find(c => c.text === atom.text || c.text.includes(atom.text) || atom.text.includes(c.text));
-        if (matchClause) {
-            clauseAtomMap.set(matchClause.text, atom.id);
-        }
-    }
-    // Fallback: asignar átomos por orden si no hay match textual
-    if (clauseAtomMap.size === 0) {
-        clauses.forEach((c, i) => {
-            const atom = allAtoms[i];
-            if (atom)
-                clauseAtomMap.set(c.text, atom.id);
-        });
-    }
     const formulas = [];
     let label = labelStart;
     switch (sentence.type) {
         case 'conditional': {
             let conditionClauses = clauses.filter(c => c.role === 'condition');
             let consequentClauses = clauses.filter(c => c.role === 'consequent' || c.role === 'conclusion' || c.role === 'assertion');
-            // Fallback: si no hay cláusula explícita de condición pero hay consequent,
-            // usar la primera cláusula que no sea consequent como condición
+            // Fallback: si no hay cláusula explícita de condición, inferir por posición
             if (conditionClauses.length === 0 && clauses.length >= 2) {
                 const nonConsequent = clauses.filter(c => c.role !== 'consequent' && c.role !== 'conclusion');
                 if (nonConsequent.length > 0) {
@@ -62,8 +74,8 @@ function buildSentenceFormulas(sentence, allAtoms, sentenceIdx, labelStart, patt
                 }
             }
             if (conditionClauses.length > 0 && consequentClauses.length > 0) {
-                const antecedent = getAtomId(conditionClauses[0].text, clauseAtomMap, allAtoms);
-                const consequent = getAtomId(consequentClauses[0].text, clauseAtomMap, allAtoms);
+                const antecedent = resolveAtom(conditionClauses[0].text, globalMap, allAtoms);
+                const consequent = resolveAtom(consequentClauses[0].text, globalMap, allAtoms);
                 // Aplicar negación si hay modificadores
                 const antStr = applyModifiers(antecedent, conditionClauses[0].modifiers.map(m => m.type));
                 const consStr = applyModifiers(consequent, consequentClauses[0].modifiers.map(m => m.type));
@@ -80,8 +92,8 @@ function buildSentenceFormulas(sentence, allAtoms, sentenceIdx, labelStart, patt
         }
         case 'biconditional': {
             if (clauses.length >= 2) {
-                const left = getAtomId(clauses[0].text, clauseAtomMap, allAtoms);
-                const right = getAtomId(clauses[1].text, clauseAtomMap, allAtoms);
+                const left = resolveAtom(clauses[0].text, globalMap, allAtoms);
+                const right = resolveAtom(clauses[1].text, globalMap, allAtoms);
                 formulas.push({
                     formula: `${left} ${connectors_1.ST_OPERATORS.biconditional} ${right}`,
                     stType: 'axiom',
@@ -94,7 +106,7 @@ function buildSentenceFormulas(sentence, allAtoms, sentenceIdx, labelStart, patt
             break;
         }
         case 'conjunction': {
-            const atoms = clauses.map(c => getAtomId(c.text, clauseAtomMap, allAtoms));
+            const atoms = clauses.map(c => resolveAtom(c.text, globalMap, allAtoms));
             if (atoms.length >= 2) {
                 const formula = atoms.join(` ${connectors_1.ST_OPERATORS.conjunction} `);
                 formulas.push({
@@ -106,10 +118,20 @@ function buildSentenceFormulas(sentence, allAtoms, sentenceIdx, labelStart, patt
                     comment: `Conjunción: "${sentence.original}"`,
                 });
             }
+            else if (atoms.length === 1) {
+                formulas.push({
+                    formula: atoms[0],
+                    stType: 'axiom',
+                    label: `hecho_${label}`,
+                    sourceText: sentence.original,
+                    sourceSentence: sentenceIdx,
+                    comment: `Hecho: "${sentence.original}"`,
+                });
+            }
             break;
         }
         case 'disjunction': {
-            const atoms = clauses.map(c => getAtomId(c.text, clauseAtomMap, allAtoms));
+            const atoms = clauses.map(c => resolveAtom(c.text, globalMap, allAtoms));
             if (atoms.length >= 2) {
                 const formula = atoms.join(` ${connectors_1.ST_OPERATORS.disjunction} `);
                 formulas.push({
@@ -125,7 +147,7 @@ function buildSentenceFormulas(sentence, allAtoms, sentenceIdx, labelStart, patt
         }
         case 'negation': {
             if (clauses.length > 0) {
-                const atom = getAtomId(clauses[0].text, clauseAtomMap, allAtoms);
+                const atom = resolveAtom(clauses[0].text, globalMap, allAtoms);
                 formulas.push({
                     formula: `${connectors_1.ST_OPERATORS.negation}(${atom})`,
                     stType: 'axiom',
@@ -138,12 +160,12 @@ function buildSentenceFormulas(sentence, allAtoms, sentenceIdx, labelStart, patt
             break;
         }
         case 'complex': {
-            // Oraciones complejas con premisas y conclusiones
+            // Oraciones complejas con premisas y conclusiones explícitas
             const premiseClauses = clauses.filter(c => c.role === 'premise');
             const conclusionClauses = clauses.filter(c => c.role === 'conclusion');
             // Generar axiomas para premisas
             for (const pClause of premiseClauses) {
-                const atom = getAtomId(pClause.text, clauseAtomMap, allAtoms);
+                const atom = resolveAtom(pClause.text, globalMap, allAtoms);
                 const atomStr = applyModifiers(atom, pClause.modifiers.map(m => m.type));
                 formulas.push({
                     formula: atomStr,
@@ -157,10 +179,7 @@ function buildSentenceFormulas(sentence, allAtoms, sentenceIdx, labelStart, patt
             // Generar derivaciones para conclusiones
             if (conclusionClauses.length > 0 && premiseClauses.length > 0) {
                 for (const cClause of conclusionClauses) {
-                    const atom = getAtomId(cClause.text, clauseAtomMap, allAtoms);
-                    const premiseLabels = formulas
-                        .filter(f => f.stType === 'axiom')
-                        .map(f => f.label);
+                    const atom = resolveAtom(cClause.text, globalMap, allAtoms);
                     formulas.push({
                         formula: atom,
                         stType: 'derive',
@@ -176,10 +195,9 @@ function buildSentenceFormulas(sentence, allAtoms, sentenceIdx, labelStart, patt
         default: {
             // Aserción simple o tipo no manejado arriba
             for (const clause of clauses) {
-                const atom = getAtomId(clause.text, clauseAtomMap, allAtoms);
+                const atom = resolveAtom(clause.text, globalMap, allAtoms);
                 const atomStr = applyModifiers(atom, clause.modifiers.map(m => m.type));
                 const isConclusion = clause.role === 'conclusion';
-                const isPremise = clause.role === 'premise' || clause.role === 'assertion';
                 formulas.push({
                     formula: atomStr,
                     stType: isConclusion ? 'derive' : 'axiom',
@@ -198,25 +216,31 @@ function buildSentenceFormulas(sentence, allAtoms, sentenceIdx, labelStart, patt
     return formulas;
 }
 /**
- * Obtiene el ID de átomo para un texto de cláusula.
+ * Resuelve el ID de átomo para un texto de cláusula.
+ * Usa el mapa global, luego busca en todos los átomos.
  */
-function getAtomId(clauseText, clauseAtomMap, allAtoms) {
-    // Buscar en el mapa directo
-    const direct = clauseAtomMap.get(clauseText);
-    if (direct)
-        return direct;
-    // Buscar match parcial
-    for (const [text, id] of clauseAtomMap) {
+function resolveAtom(clauseText, globalMap, allAtoms) {
+    // 1. Buscar en el mapa global (ya resuelto)
+    const fromMap = globalMap.get(clauseText);
+    if (fromMap)
+        return fromMap;
+    // 2. Match parcial en mapa global
+    for (const [text, id] of globalMap) {
         if (clauseText.includes(text) || text.includes(clauseText)) {
             return id;
         }
     }
-    // Buscar en todos los átomos
+    // 3. Buscar en todos los átomos por texto
     const atomMatch = allAtoms.find(a => a.text === clauseText || a.text.includes(clauseText) || clauseText.includes(a.text));
     if (atomMatch)
         return atomMatch.id;
-    // Fallback: generar ID del texto
-    return clauseText.replace(/\s+/g, '_').toUpperCase().slice(0, 20);
+    // 4. Fallback: generar ID del texto
+    return clauseText
+        .normalize('NFD').replace(/[\u0300-\u036f]/g, '')
+        .replace(/[^a-zA-Z0-9\s]/g, '')
+        .replace(/\s+/g, '_')
+        .toUpperCase()
+        .slice(0, 30) || 'ATOM';
 }
 /**
  * Aplica modificadores lógicos a una fórmula atómica.