@stevenvo780/st-lang 4.11.0 → 4.12.0

package/dist/proof-systems/fol-prover-advanced/resolve.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetRenameCounter = resetRenameCounter;
+exports.renameClause = renameClause;
+exports.binaryResolve = binaryResolve;
+exports.hyperresolve = hyperresolve;
+exports.hyperresolveMany = hyperresolveMany;
+exports.factor = factor;
+exports.dedupLiterals = dedupLiterals;
+exports.isTautology = isTautology;
+const unify_1 = require("./unify");
+let renameCounter = 0;
+function resetRenameCounter() {
+    renameCounter = 0;
+}
+/**
+ * Renombra todas las variables de una cláusula con sufijos frescos, para
+ * evitar captura accidental al resolver con otra cláusula.
+ */
+function renameClause(c) {
+    renameCounter += 1;
+    const suffix = `_r${renameCounter}`;
+    const cache = new Map();
+    return {
+        literals: c.literals.map((l) => ({
+            negated: l.negated,
+            predicate: l.predicate,
+            args: l.args.map((a) => renameTerm(a, suffix, cache))
+        })),
+        parents: c.parents,
+        fromGoal: c.fromGoal
+    };
+}
+function renameTerm(t, suffix, cache) {
+    if (t.kind === 'variable') {
+        const existing = cache.get(t.name);
+        if (existing)
+            return existing;
+        const fresh = { kind: 'variable', name: `${t.name}${suffix}` };
+        cache.set(t.name, fresh);
+        return fresh;
+    }
+    return {
+        kind: 'function',
+        name: t.name,
+        args: t.args.map((a) => renameTerm(a, suffix, cache))
+    };
+}
+/**
+ * Resolución binaria: une dos cláusulas eliminando un par de literales
+ * complementarias unificables. Devuelve cero o más resolventes (uno por par
+ * de literales complementarias que unifiquen).
+ */
+function binaryResolve(a, b) {
+    const out = [];
+    const aR = renameClause(a);
+    const bR = renameClause(b);
+    for (let i = 0; i < aR.literals.length; i++) {
+        for (let j = 0; j < bR.literals.length; j++) {
+            const la = aR.literals[i];
+            const lb = bR.literals[j];
+            if (!la || !lb)
+                continue;
+            if (la.negated === lb.negated)
+                continue;
+            const sub = (0, unify_1.unifyLiterals)({ ...la, negated: false }, { ...lb, negated: false });
+            if (!sub)
+                continue;
+            const remaining = [];
+            for (let k = 0; k < aR.literals.length; k++) {
+                if (k === i)
+                    continue;
+                const lit = aR.literals[k];
+                if (lit)
+                    remaining.push((0, unify_1.applySubToLiteral)(lit, sub));
+            }
+            for (let k = 0; k < bR.literals.length; k++) {
+                if (k === j)
+                    continue;
+                const lit = bR.literals[k];
+                if (lit)
+                    remaining.push((0, unify_1.applySubToLiteral)(lit, sub));
+            }
+            out.push({ clause: dedupLiterals({ literals: remaining }), sub });
+        }
+    }
+    return out;
+}
+/**
+ * Hyperresolución: en un solo paso, elimina **todas** las literales negativas
+ * de un "núcleo" (nucleus) usando cláusulas auxiliares positivas (electrons)
+ * que sean unitarias o tengan sólo literales positivas. El resultado es una
+ * cláusula con sólo literales positivas (positive hyperresolvent).
+ *
+ * `positive` aquí es una lista; en la práctica el caller pasa cláusulas
+ * positivas candidatas y la función produce todos los hyperresolventes
+ * posibles del núcleo contra ese conjunto. Para mantener la API del spec,
+ * exportamos `hyperresolve(positive, nucleus)` con la primera cláusula como
+ * electron (cubre el caso "3 units + nucleus" si se llama en cadena).
+ */
+function hyperresolve(positive, nucleus) {
+    return hyperresolveMany([positive], nucleus).map((r) => r.clause);
+}
+function hyperresolveMany(positives, nucleus) {
+    // Núcleo debe tener al menos una literal negativa para ser candidato.
+    const negativeIdxs = nucleus.literals
+        .map((l, i) => ({ l, i }))
+        .filter(({ l }) => l && l.negated)
+        .map(({ i }) => i);
+    if (negativeIdxs.length === 0)
+        return [];
+    // Electrons válidos: cláusulas con sólo literales positivas (≥1 literal).
+    const electrons = positives.filter((c) => c.literals.length > 0 && c.literals.every((l) => !l.negated));
+    if (electrons.length === 0)
+        return [];
+    const nucleusR = renameClause(nucleus);
+    // Re-mapear índices originales tras el renombre (mismo orden).
+    const negIdxsRenamed = nucleusR.literals
+        .map((l, i) => ({ l, i }))
+        .filter(({ l }) => l && l.negated)
+        .map(({ i }) => i);
+    const start = {
+        nucleus: nucleusR,
+        remaining: negIdxsRenamed,
+        sub: new Map(),
+        used: []
+    };
+    const results = [];
+    const stack = [start];
+    while (stack.length > 0) {
+        const state = stack.pop();
+        if (!state)
+            break;
+        if (state.remaining.length === 0) {
+            // Todas las literales negativas eliminadas → emitir el residual.
+            const survivors = [];
+            const removedSet = new Set(negIdxsRenamed);
+            for (let i = 0; i < state.nucleus.literals.length; i++) {
+                if (removedSet.has(i))
+                    continue;
+                const lit = state.nucleus.literals[i];
+                if (lit)
+                    survivors.push((0, unify_1.applySubToLiteral)(lit, state.sub));
+            }
+            results.push({
+                clause: dedupLiterals({ literals: survivors }),
+                sub: state.sub,
+                usedElectrons: state.used
+            });
+            continue;
+        }
+        const targetIdx = state.remaining[0];
+        if (targetIdx === undefined)
+            continue;
+        const target = state.nucleus.literals[targetIdx];
+        if (!target)
+            continue;
+        const targetApplied = (0, unify_1.applySubToLiteral)(target, state.sub);
+        for (let ei = 0; ei < electrons.length; ei++) {
+            const electron = electrons[ei];
+            if (!electron)
+                continue;
+            const eR = renameClause(electron);
+            for (let li = 0; li < eR.literals.length; li++) {
+                const candidate = eR.literals[li];
+                if (!candidate)
+                    continue;
+                const partial = (0, unify_1.unifyLiterals)({ ...targetApplied, negated: false }, { ...candidate, negated: false });
+                if (!partial)
+                    continue;
+                // Componer sustituciones
+                const combined = new Map();
+                for (const [k, v] of state.sub)
+                    combined.set(k, (0, unify_1.applySubToTerm)(v, partial));
+                for (const [k, v] of partial) {
+                    if (!combined.has(k))
+                        combined.set(k, v);
+                }
+                // Si el electron tiene más literales (no unitario), se añaden al residual.
+                const extra = [];
+                for (let k = 0; k < eR.literals.length; k++) {
+                    if (k === li)
+                        continue;
+                    const ex = eR.literals[k];
+                    if (ex)
+                        extra.push(ex);
+                }
+                // Extender la cláusula del núcleo con las extras (vía agregar al final
+                // como literales aplicadas, manteniendo índices remaining intactos).
+                const extendedNucleus = {
+                    literals: [...state.nucleus.literals, ...extra],
+                    parents: state.nucleus.parents,
+                    fromGoal: state.nucleus.fromGoal
+                };
+                stack.push({
+                    nucleus: extendedNucleus,
+                    remaining: state.remaining.slice(1),
+                    sub: combined,
+                    used: [...state.used, ei]
+                });
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Factoring: si dos literales del mismo signo unifican, colapsarlas reduce la
+ * cláusula. Indispensable para completar la resolución.
+ */
+function factor(c) {
+    const out = [];
+    for (let i = 0; i < c.literals.length; i++) {
+        for (let j = i + 1; j < c.literals.length; j++) {
+            const li = c.literals[i];
+            const lj = c.literals[j];
+            if (!li || !lj)
+                continue;
+            if (li.negated !== lj.negated)
+                continue;
+            const sub = (0, unify_1.unifyLiterals)({ ...li, negated: false }, { ...lj, negated: false });
+            if (!sub)
+                continue;
+            const survivors = [];
+            for (let k = 0; k < c.literals.length; k++) {
+                if (k === j)
+                    continue;
+                const lit = c.literals[k];
+                if (lit)
+                    survivors.push((0, unify_1.applySubToLiteral)(lit, sub));
+            }
+            out.push(dedupLiterals({ literals: survivors }));
+        }
+    }
+    return out;
+}
+function dedupLiterals(c) {
+    const seen = [];
+    for (const l of c.literals) {
+        if (!seen.some((s) => (0, unify_1.literalsEqual)(s, l)))
+            seen.push(l);
+    }
+    return { literals: seen, parents: c.parents, fromGoal: c.fromGoal };
+}
+/** Detecta cláusulas tautológicas (P ∨ ¬P). */
+function isTautology(c) {
+    for (let i = 0; i < c.literals.length; i++) {
+        for (let j = i + 1; j < c.literals.length; j++) {
+            const li = c.literals[i];
+            const lj = c.literals[j];
+            if (!li || !lj)
+                continue;
+            if (li.negated === lj.negated)
+                continue;
+            if (li.predicate !== lj.predicate)
+                continue;
+            if (li.args.length !== lj.args.length)
+                continue;
+            let same = true;
+            for (let k = 0; k < li.args.length; k++) {
+                const a = li.args[k];
+                const b = lj.args[k];
+                if (!a || !b) {
+                    same = false;
+                    break;
+                }
+                if (!termsEqualLocal(a, b)) {
+                    same = false;
+                    break;
+                }
+            }
+            if (same)
+                return true;
+        }
+    }
+    return false;
+}
+function termsEqualLocal(a, b) {
+    if (a.kind !== b.kind)
+        return false;
+    if (a.kind === 'variable' && b.kind === 'variable')
+        return a.name === b.name;
+    if (a.kind === 'function' && b.kind === 'function') {
+        if (a.name !== b.name || a.args.length !== b.args.length)
+            return false;
+        for (let i = 0; i < a.args.length; i++) {
+            const ai = a.args[i];
+            const bi = b.args[i];
+            if (ai === undefined || bi === undefined)
+                return false;
+            if (!termsEqualLocal(ai, bi))
+                return false;
+        }
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=resolve.js.map

package/dist/proof-systems/fol-prover-advanced/resolve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.js","sourceRoot":"","sources":["../../../src/proof-systems/fol-prover-advanced/resolve.ts"],"names":[],"mappings":"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"}

package/dist/proof-systems/fol-prover-advanced/subsumption.d.ts

@@ -0,0 +1,28 @@
+import type { FOLClause } from './types';
+/**
+ * Subsumption clásico: c1 subsume c2 si existe una sustitución σ tal que
+ * cada literal de c1·σ aparece en c2.
+ *
+ * Estrategia: backtracking sobre el matching de cada literal de c1 contra c2.
+ * Costoso en el caso general, pero acotado: cláusulas en pruebas reales
+ * tienen pocas literales.
+ */
+export declare function subsumes(c1: FOLClause, c2: FOLClause): boolean;
+/**
+ * Filtra cláusulas dejando sólo las no-subsumidas por otras del mismo set.
+ * Conserva orden de la primera aparición.
+ */
+export declare function removeSubsumed(clauses: FOLClause[]): FOLClause[];
+/**
+ * Igualdad sintáctica módulo orden de literales y renombre de variables
+ * (alpha-equivalencia simple). Suficiente para detectar duplicados producidos
+ * por resolución sobre instancias renombradas.
+ */
+export declare function clausesAlphaEqual(a: FOLClause, b: FOLClause): boolean;
+/**
+ * Reordena cláusulas para que las unitarias (1 literal) vayan primero.
+ * Patrón "unit preference" — reduce drásticamente el espacio de búsqueda en
+ * problemas tipo modus-ponens encadenado.
+ */
+export declare function unitPreference(clauses: FOLClause[]): FOLClause[];
+//# sourceMappingURL=subsumption.d.ts.map

package/dist/proof-systems/fol-prover-advanced/subsumption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subsumption.d.ts","sourceRoot":"","sources":["../../../src/proof-systems/fol-prover-advanced/subsumption.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAqC,MAAM,SAAS,CAAC;AAG5E;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,GAAG,OAAO,CAI9D;AA2ED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,CAsBhE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,OAAO,CAerE;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,CAEhE"}

package/dist/proof-systems/fol-prover-advanced/subsumption.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subsumes = subsumes;
+exports.removeSubsumed = removeSubsumed;
+exports.clausesAlphaEqual = clausesAlphaEqual;
+exports.unitPreference = unitPreference;
+const unify_1 = require("./unify");
+/**
+ * Subsumption clásico: c1 subsume c2 si existe una sustitución σ tal que
+ * cada literal de c1·σ aparece en c2.
+ *
+ * Estrategia: backtracking sobre el matching de cada literal de c1 contra c2.
+ * Costoso en el caso general, pero acotado: cláusulas en pruebas reales
+ * tienen pocas literales.
+ */
+function subsumes(c1, c2) {
+    if (c1.literals.length === 0)
+        return true; // ⊥ subsume todo
+    if (c1.literals.length > c2.literals.length)
+        return false;
+    return matchLiterals(c1.literals, c2.literals, new Map());
+}
+function matchLiterals(remaining, target, sub) {
+    if (remaining.length === 0)
+        return true;
+    const first = remaining[0];
+    if (!first)
+        return true;
+    const rest = remaining.slice(1);
+    for (const lit of target) {
+        const extended = matchLiteral(first, lit, new Map(sub));
+        if (extended && matchLiterals(rest, target, extended))
+            return true;
+    }
+    return false;
+}
+function matchLiteral(pattern, target, sub) {
+    if (pattern.negated !== target.negated)
+        return null;
+    if (pattern.predicate !== target.predicate)
+        return null;
+    if (pattern.args.length !== target.args.length)
+        return null;
+    let current = sub;
+    for (let i = 0; i < pattern.args.length; i++) {
+        const a = pattern.args[i];
+        const b = target.args[i];
+        if (a === undefined || b === undefined)
+            return null;
+        const next = matchTerm(a, b, current);
+        if (!next)
+            return null;
+        current = next;
+    }
+    return current;
+}
+/**
+ * Matching unidireccional (no unificación): sólo variables del `pattern` se
+ * sustituyen; los términos del `target` se mantienen fijos.
+ */
+function matchTerm(pattern, target, sub) {
+    if (pattern.kind === 'variable') {
+        const existing = sub.get(pattern.name);
+        if (existing) {
+            return termsEqual((0, unify_1.applySubToTerm)(existing, sub), target) ? sub : null;
+        }
+        const next = new Map(sub);
+        next.set(pattern.name, target);
+        return next;
+    }
+    if (target.kind === 'variable')
+        return null;
+    if (pattern.name !== target.name)
+        return null;
+    if (pattern.args.length !== target.args.length)
+        return null;
+    let current = sub;
+    for (let i = 0; i < pattern.args.length; i++) {
+        const a = pattern.args[i];
+        const b = target.args[i];
+        if (a === undefined || b === undefined)
+            return null;
+        const next = matchTerm(a, b, current);
+        if (!next)
+            return null;
+        current = next;
+    }
+    return current;
+}
+function termsEqual(a, b) {
+    if (a.kind !== b.kind)
+        return false;
+    if (a.kind === 'variable' && b.kind === 'variable')
+        return a.name === b.name;
+    if (a.kind === 'function' && b.kind === 'function') {
+        if (a.name !== b.name || a.args.length !== b.args.length)
+            return false;
+        for (let i = 0; i < a.args.length; i++) {
+            const ai = a.args[i];
+            const bi = b.args[i];
+            if (ai === undefined || bi === undefined)
+                return false;
+            if (!termsEqual(ai, bi))
+                return false;
+        }
+        return true;
+    }
+    return false;
+}
+/**
+ * Filtra cláusulas dejando sólo las no-subsumidas por otras del mismo set.
+ * Conserva orden de la primera aparición.
+ */
+function removeSubsumed(clauses) {
+    const kept = [];
+    for (let i = 0; i < clauses.length; i++) {
+        const c = clauses[i];
+        if (!c)
+            continue;
+        let dominated = false;
+        for (let j = 0; j < clauses.length; j++) {
+            if (i === j)
+                continue;
+            const other = clauses[j];
+            if (!other)
+                continue;
+            if (clausesAlphaEqual(c, other) && j < i) {
+                dominated = true; // duplicado posterior
+                break;
+            }
+            if (!clausesAlphaEqual(c, other) && subsumes(other, c)) {
+                dominated = true;
+                break;
+            }
+        }
+        if (!dominated)
+            kept.push(c);
+    }
+    return kept;
+}
+/**
+ * Igualdad sintáctica módulo orden de literales y renombre de variables
+ * (alpha-equivalencia simple). Suficiente para detectar duplicados producidos
+ * por resolución sobre instancias renombradas.
+ */
+function clausesAlphaEqual(a, b) {
+    if (a.literals.length !== b.literals.length)
+        return false;
+    const matched = new Array(b.literals.length).fill(false);
+    outer: for (const la of a.literals) {
+        for (let i = 0; i < b.literals.length; i++) {
+            if (matched[i])
+                continue;
+            const lb = b.literals[i];
+            if (lb && (0, unify_1.literalsEqual)(la, lb)) {
+                matched[i] = true;
+                continue outer;
+            }
+        }
+        return false;
+    }
+    return true;
+}
+/**
+ * Reordena cláusulas para que las unitarias (1 literal) vayan primero.
+ * Patrón "unit preference" — reduce drásticamente el espacio de búsqueda en
+ * problemas tipo modus-ponens encadenado.
+ */
+function unitPreference(clauses) {
+    return [...clauses].sort((a, b) => a.literals.length - b.literals.length);
+}
+//# sourceMappingURL=subsumption.js.map

package/dist/proof-systems/fol-prover-advanced/subsumption.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subsumption.js","sourceRoot":"","sources":["../../../src/proof-systems/fol-prover-advanced/subsumption.ts"],"names":[],"mappings":";;AAWA,4BAIC;AA+ED,wCAsBC;AAOD,8CAeC;AAOD,wCAEC;AAlJD,mCAAwD;AAExD;;;;;;;GAOG;AACH,SAAgB,QAAQ,CAAC,EAAa,EAAE,EAAa;IACnD,IAAI,EAAE,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC,CAAC,iBAAiB;IAC5D,IAAI,EAAE,CAAC,QAAQ,CAAC,MAAM,GAAG,EAAE,CAAC,QAAQ,CAAC,MAAM;QAAE,OAAO,KAAK,CAAC;IAC1D,OAAO,aAAa,CAAC,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,EAAE,IAAI,GAAG,EAAE,CAAC,CAAC;AAC5D,CAAC;AAED,SAAS,aAAa,CAAC,SAAuB,EAAE,MAAoB,EAAE,GAAiB;IACrF,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACxC,MAAM,KAAK,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;IAC3B,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAC;IACxB,MAAM,IAAI,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAChC,KAAK,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;QACzB,MAAM,QAAQ,GAAG,YAAY,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;QACxD,IAAI,QAAQ,IAAI,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC;YAAE,OAAO,IAAI,CAAC;IACrE,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,YAAY,CAAC,OAAmB,EAAE,MAAkB,EAAE,GAAiB;IAC9E,IAAI,OAAO,CAAC,OAAO,KAAK,MAAM,CAAC,OAAO;QAAE,OAAO,IAAI,CAAC;IACpD,IAAI,OAAO,CAAC,SAAS,KAAK,MAAM,CAAC,SAAS;QAAE,OAAO,IAAI,CAAC;IACxD,IAAI,OAAO,CAAC,IAAI,CAAC,MAAM,KAAK,MAAM,CAAC,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IAC5D,IAAI,OAAO,GAAG,GAAG,CAAC;IAClB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC7C,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC1B,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACzB,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC;QACpD,MAAM,IAAI,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC;QACtC,IAAI,CAAC,IAAI;YAAE,OAAO,IAAI,CAAC;QACvB,OAAO,GAAG,IAAI,CAAC;IACjB,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;GAGG;AACH,SAAS,SAAS,CAAC,OAAgB,EAAE,MAAe,EAAE,GAAiB;IACrE,IAAI,OAAO,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;QAChC,MAAM,QAAQ,GAAG,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACvC,IAAI,QAAQ,EAAE,CAAC;YACb,OAAO,UAAU,CAAC,IAAA,sBAAc,EAAC,QAAQ,EAAE,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;QACxE,CAAC;QACD,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;QAC1B,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAC/B,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,MAAM,CAAC,IAAI,KAAK,UAAU;QAAE,OAAO,IAAI,CAAC;IAC5C,IAAI,OAAO,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI;QAAE,OAAO,IAAI,CAAC;IAC9C,IAAI,OAAO,CAAC,IAAI,CAAC,MAAM,KAAK,MAAM,CAAC,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IAC5D,IAAI,OAAO,GAAG,GAAG,CAAC;IAClB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC7C,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC1B,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACzB,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC;QACpD,MAAM,IAAI,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC;QACtC,IAAI,CAAC,IAAI;YAAE,OAAO,IAAI,CAAC;QACvB,OAAO,GAAG,IAAI,CAAC;IACjB,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,SAAS,UAAU,CAAC,CAAU,EAAE,CAAU;IACxC,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI;QAAE,OAAO,KAAK,CAAC;IACpC,IAAI,CAAC,CAAC,IAAI,KAAK,UAAU,IAAI,CAAC,CAAC,IAAI,KAAK,UAAU;QAAE,OAAO,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI,CAAC;IAC7E,IAAI,CAAC,CAAC,IAAI,KAAK,UAAU,IAAI,CAAC,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;QACnD,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC,IAAI,CAAC,MAAM;YAAE,OAAO,KAAK,CAAC;QACvE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACvC,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACrB,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACrB,IAAI,EAAE,KAAK,SAAS,IAAI,EAAE,KAAK,SAAS;gBAAE,OAAO,KAAK,CAAC;YACvD,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC;gBAAE,OAAO,KAAK,CAAC;QACxC,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;GAGG;AACH,SAAgB,cAAc,CAAC,OAAoB;IACjD,MAAM,IAAI,GAAgB,EAAE,CAAC;IAC7B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACxC,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QACrB,IAAI,CAAC,CAAC;YAAE,SAAS;QACjB,IAAI,SAAS,GAAG,KAAK,CAAC;QACtB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,IAAI,CAAC,KAAK,CAAC;gBAAE,SAAS;YACtB,MAAM,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YACzB,IAAI,CAAC,KAAK;gBAAE,SAAS;YACrB,IAAI,iBAAiB,CAAC,CAAC,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;gBACzC,SAAS,GAAG,IAAI,CAAC,CAAC,sBAAsB;gBACxC,MAAM;YACR,CAAC;YACD,IAAI,CAAC,iBAAiB,CAAC,CAAC,EAAE,KAAK,CAAC,IAAI,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC;gBACvD,SAAS,GAAG,IAAI,CAAC;gBACjB,MAAM;YACR,CAAC;QACH,CAAC;QACD,IAAI,CAAC,SAAS;YAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC/B,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;GAIG;AACH,SAAgB,iBAAiB,CAAC,CAAY,EAAE,CAAY;IAC1D,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC,QAAQ,CAAC,MAAM;QAAE,OAAO,KAAK,CAAC;IAC1D,MAAM,OAAO,GAAG,IAAI,KAAK,CAAU,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAClE,KAAK,EAAE,KAAK,MAAM,EAAE,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC;QACnC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3C,IAAI,OAAO,CAAC,CAAC,CAAC;gBAAE,SAAS;YACzB,MAAM,EAAE,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;YACzB,IAAI,EAAE,IAAI,IAAA,qBAAa,EAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC;gBAChC,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;gBAClB,SAAS,KAAK,CAAC;YACjB,CAAC;QACH,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;GAIG;AACH,SAAgB,cAAc,CAAC,OAAoB;IACjD,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;AAC5E,CAAC"}

package/dist/proof-systems/fol-prover-advanced/types.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Tipos base de primer orden para el prover avanzado.
+ *
+ * Variables: identificadores que empiezan con minúscula y se interpretan como
+ * sustituibles durante la unificación (convención: `x`, `y`, `u`, `v`).
+ * Constantes/funciones: identificadores en minúscula con `args` (aridad ≥ 0).
+ * Diferenciamos `variable` vs `function` por el campo `kind` para evitar
+ * ambigüedades.
+ */
+export type FOLTerm = {
+    kind: 'variable';
+    name: string;
+} | {
+    kind: 'function';
+    name: string;
+    args: FOLTerm[];
+};
+export interface FOLLiteral {
+    /** Si la literal está negada (¬P(x)) o es positiva (P(x)). */
+    negated: boolean;
+    predicate: string;
+    args: FOLTerm[];
+}
+export interface FOLClause {
+    /** Disyunción de literales. Cláusula vacía ⇒ contradicción. */
+    literals: FOLLiteral[];
+    /** Trazabilidad: índices de cláusulas padre (si fue derivada). */
+    parents?: number[];
+    /** Marca cláusulas que provienen del goal o su negación (SoS). */
+    fromGoal?: boolean;
+}
+export type Substitution = Map<string, FOLTerm>;
+export type RefinementStrategy = 'binary' | 'hyperresolution' | 'set-of-support' | 'ordered' | 'unit-preference';
+export type TermOrdering = 'KBO' | 'LPO' | 'none';
+export interface AdvancedProveOptions {
+    strategy: RefinementStrategy;
+    ordering?: TermOrdering;
+    /** Pesos para KBO (símbolo → peso). Variables tienen peso fijo 1. */
+    kboWeights?: Map<string, number>;
+    /** Precedencia para LPO/ordered (símbolo → rank; mayor = más fuerte). */
+    precedence?: Map<string, number>;
+    /** Índices (en `premises` + goal-negado) que arrancan en el set-of-support. */
+    setOfSupport?: number[];
+    timeoutMs?: number;
+    maxSteps?: number;
+}
+export interface ProofStep {
+    rule: string;
+    from: number[];
+    result: FOLClause;
+    substitution?: Substitution;
+}
+export interface ProofStats {
+    resolutions: number;
+    subsumed: number;
+    deduplicated: number;
+    hyperresolutions: number;
+    factored: number;
+    steps: number;
+}
+export interface AdvancedProveResult {
+    proven: boolean;
+    steps: ProofStep[];
+    stats: ProofStats;
+    /** Razón cuando `proven=false`: timeout, saturated, maxSteps. */
+    termination: 'refuted' | 'saturated' | 'timeout' | 'max-steps';
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/proof-systems/fol-prover-advanced/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/proof-systems/fol-prover-advanced/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,MAAM,OAAO,GACf;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,EAAE,CAAA;CAAE,CAAC;AAExD,MAAM,WAAW,UAAU;IACzB,8DAA8D;IAC9D,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,OAAO,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,SAAS;IACxB,+DAA+D;IAC/D,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB,kEAAkE;IAClE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,kEAAkE;IAClE,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,MAAM,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEhD,MAAM,MAAM,kBAAkB,GAC1B,QAAQ,GACR,iBAAiB,GACjB,gBAAgB,GAChB,SAAS,GACT,iBAAiB,CAAC;AAEtB,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;AAElD,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,qEAAqE;IACrE,UAAU,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,yEAAyE;IACzE,UAAU,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,+EAA+E;IAC/E,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,MAAM,EAAE,SAAS,CAAC;IAClB,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;AAED,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,KAAK,EAAE,UAAU,CAAC;IAClB,iEAAiE;IACjE,WAAW,EAAE,SAAS,GAAG,WAAW,GAAG,SAAS,GAAG,WAAW,CAAC;CAChE"}

package/dist/proof-systems/fol-prover-advanced/types.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * Tipos base de primer orden para el prover avanzado.
+ *
+ * Variables: identificadores que empiezan con minúscula y se interpretan como
+ * sustituibles durante la unificación (convención: `x`, `y`, `u`, `v`).
+ * Constantes/funciones: identificadores en minúscula con `args` (aridad ≥ 0).
+ * Diferenciamos `variable` vs `function` por el campo `kind` para evitar
+ * ambigüedades.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/proof-systems/fol-prover-advanced/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/proof-systems/fol-prover-advanced/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG"}

package/dist/proof-systems/fol-prover-advanced/unify.d.ts

@@ -0,0 +1,15 @@
+import type { FOLLiteral, FOLTerm, Substitution } from './types';
+/**
+ * Unificación de Robinson con occurs-check. Devuelve la sustitución más
+ * general (mgu) o `null` si no unifica.
+ *
+ * Implementación iterativa sobre una pila de pares (t1,t2) para evitar
+ * recursión profunda en cláusulas grandes.
+ */
+export declare function unify(t1: FOLTerm, t2: FOLTerm): Substitution | null;
+export declare function unifyLiterals(l1: FOLLiteral, l2: FOLLiteral): Substitution | null;
+export declare function applySubToTerm(t: FOLTerm, sub: Substitution): FOLTerm;
+export declare function applySubToLiteral(l: FOLLiteral, sub: Substitution): FOLLiteral;
+export declare function termsEqual(a: FOLTerm, b: FOLTerm): boolean;
+export declare function literalsEqual(a: FOLLiteral, b: FOLLiteral): boolean;
+//# sourceMappingURL=unify.d.ts.map

package/dist/proof-systems/fol-prover-advanced/unify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unify.d.ts","sourceRoot":"","sources":["../../../src/proof-systems/fol-prover-advanced/unify.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEjE;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,GAAG,YAAY,GAAG,IAAI,CAkCnE;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,UAAU,EAAE,EAAE,EAAE,UAAU,GAAG,YAAY,GAAG,IAAI,CAejF;AAED,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO,CAYrE;AAED,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,UAAU,EAAE,GAAG,EAAE,YAAY,GAAG,UAAU,CAM9E;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAc1D;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,OAAO,CAWnE"}