@stevenvo780/st-lang 4.2.0 → 4.4.0

package/dist/runtime/abduction/find.js

@@ -0,0 +1,202 @@
+"use strict";
+// ============================================================
+// ST Abduction — Núcleo: búsqueda de explicaciones
+// ============================================================
+//
+// Estrategia: enumeración por tamaño creciente (BFS sobre subsets).
+//
+//   for k in 0..maxSize:
+//     for cada subset H ⊆ abducibles con |H| = k:
+//       si KB ∪ H ⊨ O y KB ∪ H consistent:
+//         registrar H como explicación
+//         marcar todos sus supersets como redundantes (no parsimoniosos)
+//
+// Las explicaciones se reportan ordenadas por tamaño ascendente. La
+// minimalidad por inclusión se verifica al final con una pasada O(N²)
+// sobre las explicaciones encontradas (suficiente para |explicaciones|
+// ≲ algunos miles; en problemas grandes acotar `maxHypotheses`).
+//
+// Para `preferred = 'minimal'`, solo se reportan las parsimoniosas.
+// Para `minimum-cardinality`, se reportan únicamente las de tamaño
+// igual al mínimo encontrado. Para `minimum-cost`, las de costo
+// mínimo (requiere costFunction o se usa size).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findExplanations = findExplanations;
+exports.bestExplanation = bestExplanation;
+const entails_1 = require("./entails");
+function resolveOptions(abducibles, opts) {
+    const entails = opts?.entails ?? (0, entails_1.defaultEntails)();
+    const consistent = opts?.consistent ?? (0, entails_1.defaultConsistent)();
+    return {
+        entails,
+        consistent,
+        maxHypotheses: opts?.maxHypotheses ?? 1024,
+        maxSize: opts?.maxSize ?? abducibles.length,
+        costFunction: opts?.costFunction ?? (() => 1),
+        preferred: opts?.preferred ?? 'minimal',
+    };
+}
+/** Itera sobre todos los subsets de [0..n) de tamaño exactamente k (orden lex). */
+function* combinations(n, k) {
+    if (k < 0 || k > n)
+        return;
+    if (k === 0) {
+        yield [];
+        return;
+    }
+    const idx = new Array(k);
+    for (let i = 0; i < k; i++)
+        idx[i] = i;
+    while (true) {
+        yield idx.slice();
+        // Avanzar al siguiente combination en orden lex.
+        let i = k - 1;
+        while (i >= 0 && idx[i] === n - k + i)
+            i--;
+        if (i < 0)
+            return;
+        idx[i] = idx[i] + 1;
+        for (let j = i + 1; j < k; j++)
+            idx[j] = idx[j - 1] + 1;
+    }
+}
+function isSubsetOf(a, b) {
+    if (a.length > b.length)
+        return false;
+    let i = 0;
+    let j = 0;
+    while (i < a.length && j < b.length) {
+        const ai = a[i];
+        const bj = b[j];
+        if (ai === bj) {
+            i++;
+            j++;
+        }
+        else if (ai < bj) {
+            return false;
+        }
+        else {
+            j++;
+        }
+    }
+    return i === a.length;
+}
+/**
+ * Encuentra todas las explicaciones de un problema abductivo.
+ *
+ * - Enumera subsets de abducibles en orden creciente de tamaño.
+ * - Filtra los inconsistentes y los que no implican la observación.
+ * - Calcula minimalidad por inclusión (parsimony) post-hoc.
+ * - Aplica el filtro `preferred` para el output final.
+ */
+function findExplanations(problem, opts) {
+    const { kb, observation, abducibles } = problem;
+    const resolved = resolveOptions(abducibles, opts);
+    const n = abducibles.length;
+    const maxK = Math.min(resolved.maxSize, n);
+    // Pre-check: si KB ya implica O sin ninguna hipótesis, la explicación
+    // vacía es la única parsimoniosa.
+    // (Esto requiere consistencia de KB y derivación.)
+    const raw = [];
+    if (resolved.consistent(kb) && resolved.entails(kb, observation)) {
+        raw.push({ indices: [], hypotheses: [], costScore: 0 });
+    }
+    // Buscamos también H no vacíos. Si la vacía explica, según
+    // `preferred` puede ser todo lo que necesitamos (case-by-case).
+    outer: for (let k = 1; k <= maxK; k++) {
+        for (const idx of combinations(n, k)) {
+            const hypotheses = [];
+            let costScore = 0;
+            for (const i of idx) {
+                const f = abducibles[i];
+                if (f === undefined)
+                    continue;
+                hypotheses.push(f);
+                costScore += resolved.costFunction(f);
+            }
+            const combined = [...kb, ...hypotheses];
+            // Skip duplicate trivial: si algún subset menor ya está en raw y es
+            // subset de este, este NO va a ser parsimonious. Lo enumeramos
+            // igual porque `preferred=all` debe verlos, pero podemos saltarlo
+            // si `preferred` ∈ {minimal, minimum-cardinality, minimum-cost}.
+            if (resolved.preferred !== 'all' &&
+                raw.some((r) => r.indices.length < idx.length && isSubsetOf(r.indices, idx))) {
+                continue;
+            }
+            if (!resolved.consistent(combined))
+                continue;
+            if (!resolved.entails(combined, observation))
+                continue;
+            raw.push({ indices: idx, hypotheses, costScore });
+            if (raw.length >= resolved.maxHypotheses)
+                break outer;
+        }
+    }
+    // Determinar parsimony por inclusión: una H es parsimoniosa sii no
+    // existe H' ∈ raw con H' ⊂ H (subconjunto propio).
+    const parsimonyMap = new Map();
+    const keyFor = (r) => r.indices.join(',');
+    for (const r of raw) {
+        let parsim = true;
+        for (const other of raw) {
+            if (other === r)
+                continue;
+            if (other.indices.length >= r.indices.length)
+                continue;
+            if (isSubsetOf(other.indices, r.indices)) {
+                parsim = false;
+                break;
+            }
+        }
+        parsimonyMap.set(keyFor(r), parsim);
+    }
+    // Convertir a Explanation[].
+    const explanations = raw.map((r) => ({
+        hypotheses: r.hypotheses,
+        size: r.hypotheses.length,
+        parsimonious: parsimonyMap.get(keyFor(r)) ?? false,
+        costScore: r.costScore,
+    }));
+    return applyPreference(explanations, resolved);
+}
+function applyPreference(expls, resolved) {
+    if (expls.length === 0)
+        return [];
+    switch (resolved.preferred) {
+        case 'all':
+            return expls.slice();
+        case 'minimal':
+            return expls.filter((e) => e.parsimonious);
+        case 'minimum-cardinality': {
+            const minimal = expls.filter((e) => e.parsimonious);
+            if (minimal.length === 0)
+                return [];
+            const minSize = minimal.reduce((m, e) => Math.min(m, e.size), Infinity);
+            return minimal.filter((e) => e.size === minSize);
+        }
+        case 'minimum-cost': {
+            const minimal = expls.filter((e) => e.parsimonious);
+            if (minimal.length === 0)
+                return [];
+            const minCost = minimal.reduce((m, e) => Math.min(m, e.costScore ?? Infinity), Infinity);
+            return minimal.filter((e) => (e.costScore ?? Infinity) === minCost);
+        }
+        default:
+            return expls.slice();
+    }
+}
+/**
+ * Devuelve UNA explicación: la "mejor" según `preferred`. Si hay
+ * empate, la primera en orden lex (consistente y reproducible).
+ *
+ * Devuelve `null` si no hay explicación posible.
+ */
+function bestExplanation(problem, opts) {
+    // Para best-explanation, forzamos minimum-cost si hay costFunction;
+    // si no, minimum-cardinality. El cliente puede overridear con
+    // opts.preferred.
+    const preferred = opts?.preferred ?? (opts?.costFunction ? 'minimum-cost' : 'minimum-cardinality');
+    const all = findExplanations(problem, { ...opts, preferred });
+    return all.length > 0 ? all[0] : null;
+}
+//# sourceMappingURL=find.js.map

package/dist/runtime/abduction/find.js.map

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

package/dist/runtime/abduction/index.d.ts

@@ -0,0 +1,4 @@
+export { findExplanations, bestExplanation } from './find';
+export { defaultEntails, defaultConsistent } from './entails';
+export type { AbductionOptions, AbductionProblem, ConsistencyOracle, EntailmentOracle, Explanation, Formula, Preference, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/abduction/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/abduction/index.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC9D,YAAY,EACV,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,WAAW,EACX,OAAO,EACP,UAAU,GACX,MAAM,SAAS,CAAC"}

package/dist/runtime/abduction/index.js

@@ -0,0 +1,26 @@
+"use strict";
+// ============================================================
+// ST Abduction — Barrel
+// ============================================================
+//
+// Razonamiento abductivo: dado un knowledge base KB y una observación
+// O, encontrar la hipótesis mínima H ⊆ Abducibles tal que
+// KB ∪ H ⊨ O y KB ∪ H es consistente.
+//
+// API pública:
+//   - `findExplanations(problem, opts?)`  → todas las explicaciones
+//   - `bestExplanation(problem, opts?)`   → la mejor según preferencia
+//   - `defaultEntails(opts?)`             → oráculo entailment Horn-like
+//   - `defaultConsistent(opts?)`          → oráculo consistencia derivado
+//
+// Tipos: `AbductionProblem`, `Explanation`, `AbductionOptions`,
+// `EntailmentOracle`, `ConsistencyOracle`, `Preference`, `Formula`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultConsistent = exports.defaultEntails = exports.bestExplanation = exports.findExplanations = void 0;
+var find_1 = require("./find");
+Object.defineProperty(exports, "findExplanations", { enumerable: true, get: function () { return find_1.findExplanations; } });
+Object.defineProperty(exports, "bestExplanation", { enumerable: true, get: function () { return find_1.bestExplanation; } });
+var entails_1 = require("./entails");
+Object.defineProperty(exports, "defaultEntails", { enumerable: true, get: function () { return entails_1.defaultEntails; } });
+Object.defineProperty(exports, "defaultConsistent", { enumerable: true, get: function () { return entails_1.defaultConsistent; } });
+//# sourceMappingURL=index.js.map

package/dist/runtime/abduction/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime/abduction/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,wBAAwB;AACxB,+DAA+D;AAC/D,EAAE;AACF,sEAAsE;AACtE,0DAA0D;AAC1D,sCAAsC;AACtC,EAAE;AACF,eAAe;AACf,oEAAoE;AACpE,uEAAuE;AACvE,yEAAyE;AACzE,0EAA0E;AAC1E,EAAE;AACF,gEAAgE;AAChE,oEAAoE;;;AAEpE,+BAA2D;AAAlD,wGAAA,gBAAgB,OAAA;AAAE,uGAAA,eAAe,OAAA;AAC1C,qCAA8D;AAArD,yGAAA,cAAc,OAAA;AAAE,4GAAA,iBAAiB,OAAA"}

package/dist/runtime/abduction/types.d.ts

@@ -0,0 +1,78 @@
+/** Una fórmula (formato libre — strings, opaque al motor). */
+export type Formula = string;
+/**
+ * Oráculo de consecuencia lógica: dado un conjunto de premisas P y
+ * una fórmula objetivo q, devuelve `true` sii P ⊨ q.
+ *
+ * El motor abductivo es agnóstico al sistema lógico. Quien usa la
+ * librería provee este oráculo (puede ser propositional, FOL,
+ * description logic, etc).
+ */
+export type EntailmentOracle = (premises: ReadonlyArray<Formula>, target: Formula) => boolean;
+/**
+ * Oráculo de consistencia: dado un conjunto de fórmulas, devuelve
+ * `true` sii admite al menos un modelo. Default razonable: si no
+ * lo dan, decimos consistente sii NO P ⊨ ⊥. Como no tenemos ⊥
+ * estándar en strings, en la práctica conviene pasar este oráculo.
+ */
+export type ConsistencyOracle = (premises: ReadonlyArray<Formula>) => boolean;
+/**
+ * Problema abductivo.
+ *
+ * - `kb`: background knowledge (axiomas del dominio).
+ * - `observation`: fórmula que queremos explicar.
+ * - `abducibles`: el conjunto de fórmulas elegibles como hipótesis.
+ *   El razonador buscará H ⊆ abducibles.
+ */
+export interface AbductionProblem {
+    kb: ReadonlyArray<Formula>;
+    observation: Formula;
+    abducibles: ReadonlyArray<Formula>;
+}
+/**
+ * Una explicación candidata.
+ *
+ * - `hypotheses`: subconjunto de abducibles.
+ * - `size`: cardinalidad (= hypotheses.length).
+ * - `parsimonious`: true sii no existe subconjunto propio que
+ *   también explique la observación de forma consistente.
+ *   (Equivale a "minimal por inclusión".)
+ * - `costScore`: suma de costos si se proveyó costFunction.
+ */
+export interface Explanation {
+    hypotheses: ReadonlyArray<Formula>;
+    size: number;
+    parsimonious: boolean;
+    costScore?: number;
+}
+/**
+ * Criterio de preferencia sobre el conjunto de explicaciones.
+ *
+ * - `all`: todas las explicaciones encontradas (no filtra).
+ * - `minimal`: solo las minimal-por-inclusión (parsimonious).
+ * - `minimum-cardinality`: las de menor |H| entre las minimales.
+ * - `minimum-cost`: las de menor costo total (requiere costFunction).
+ */
+export type Preference = 'all' | 'minimal' | 'minimum-cardinality' | 'minimum-cost';
+export interface AbductionOptions {
+    /** Oráculo de entailment. Default: `defaultEntails` (propositional, ver entails.ts). */
+    entails?: EntailmentOracle;
+    /** Oráculo de consistencia. Default: derivado de `entails` (no entails ⊥-equiv). */
+    consistent?: ConsistencyOracle;
+    /**
+     * Tope de explicaciones a retornar. Útil cuando hay explosión
+     * combinatoria. Default: 1024.
+     */
+    maxHypotheses?: number;
+    /**
+     * Tope para |H|. Acota el espacio de búsqueda. Default: igual a
+     * |abducibles| (sin tope efectivo). Bajarlo es una buena idea
+     * para |abducibles| > 12.
+     */
+    maxSize?: number;
+    /** Función de costo por hipótesis. Default: 1 por hipótesis. */
+    costFunction?: (h: Formula) => number;
+    /** Cómo filtrar/ordenar el output. Default: `minimal`. */
+    preferred?: Preference;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/runtime/abduction/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/runtime/abduction/types.ts"],"names":[],"mappings":"AAqBA,8DAA8D;AAC9D,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC;AAE7B;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC;AAE9F;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC;AAE9E;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAC3B,WAAW,EAAE,OAAO,CAAC;IACrB,UAAU,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;CACpC;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,SAAS,GAAG,qBAAqB,GAAG,cAAc,CAAC;AAEpF,MAAM,WAAW,gBAAgB;IAC/B,wFAAwF;IACxF,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,oFAAoF;IACpF,UAAU,CAAC,EAAE,iBAAiB,CAAC;IAC/B;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gEAAgE;IAChE,YAAY,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,MAAM,CAAC;IACtC,0DAA0D;IAC1D,SAAS,CAAC,EAAE,UAAU,CAAC;CACxB"}

package/dist/runtime/abduction/types.js

@@ -0,0 +1,23 @@
+"use strict";
+// ============================================================
+// ST Abduction — Tipos públicos
+// ============================================================
+//
+// Razonamiento abductivo (Peirce 1903; Reiter 1987): dado un
+// background knowledge KB y una observación O, encontrar
+// hipótesis H ⊆ Abducibles tal que:
+//
+//   1. KB ∪ H ⊨ O       (la hipótesis explica la observación)
+//   2. KB ∪ H consistent (la hipótesis es compatible con KB)
+//   3. H es minimal (no hay H' ⊂ H que cumpla 1 y 2)
+//
+// Usos típicos:
+//   - Diagnóstico (¿qué fallas explican estos síntomas?)
+//   - Inferencia best-fit (la hipótesis más simple/barata gana)
+//   - Generación de explicaciones (debugging de cadenas causales)
+//
+// El espacio de hipótesis se enumera sobre 2^|abducibles|. Para
+// |abducibles| ≲ 16 la enumeración exhaustiva es viable. Para más
+// grande, conviene un oráculo SAT incremental.
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/runtime/abduction/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/runtime/abduction/types.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,gCAAgC;AAChC,+DAA+D;AAC/D,EAAE;AACF,6DAA6D;AAC7D,yDAAyD;AACzD,oCAAoC;AACpC,EAAE;AACF,8DAA8D;AAC9D,6DAA6D;AAC7D,qDAAqD;AACrD,EAAE;AACF,gBAAgB;AAChB,yDAAyD;AACzD,gEAAgE;AAChE,kEAAkE;AAClE,EAAE;AACF,gEAAgE;AAChE,kEAAkE;AAClE,+CAA+C"}

package/dist/runtime/anti-unification/anti-unify.d.ts

@@ -0,0 +1,22 @@
+import type { AntiUnificationResult, FreshSupply, Term } from './types';
+/**
+ * Fuente default de variables frescas: _g0, _g1, _g2, …
+ *
+ * Se devuelve una NUEVA instancia por llamada para evitar estado
+ * compartido entre invocaciones de antiUnify.
+ */
+export declare function defaultFreshSupply(prefix?: string): FreshSupply;
+/**
+ * Anti-unification de dos términos.
+ *
+ * Devuelve el lgg (least general generalization) junto con las
+ * sustituciones de izquierda y derecha que reconstruyen los
+ * términos originales.
+ *
+ * Complejidad: O(|t1| + |t2|) tiempo si la tabla se implementa con
+ * hashing O(1). Usamos `termKey` que serializa, así que es
+ * O((|t1| + |t2|)·k) donde k es el tamaño del subtérmino más grande
+ * que aparezca en un desacuerdo.
+ */
+export declare function antiUnify(t1: Term, t2: Term, freshSupply?: FreshSupply): AntiUnificationResult;
+//# sourceMappingURL=anti-unify.d.ts.map

package/dist/runtime/anti-unification/anti-unify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anti-unify.d.ts","sourceRoot":"","sources":["../../../src/runtime/anti-unification/anti-unify.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,qBAAqB,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAGxE;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,GAAE,MAAa,GAAG,WAAW,CAGrE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,qBAAqB,CAc9F"}

package/dist/runtime/anti-unification/anti-unify.js

@@ -0,0 +1,154 @@
+"use strict";
+// ============================================================
+// ST Anti-Unification — Algoritmo de Plotkin (lgg)
+// ============================================================
+//
+// Algoritmo (Plotkin 1970):
+//
+//   au(t1, t2, table):
+//     si t1 ≡ t2 estructuralmente:
+//       return t1
+//     si ambos son func/const con mismo nombre y misma aridad:
+//       return func(name, [au(t1.args[i], t2.args[i]) for i])
+//     // desacuerdo: introducimos fresh var, reusando si ya existe
+//     // una asignada al MISMO par (t1, t2) — esto es clave para que
+//     // la generalización sea LEAST (most specific).
+//     si table tiene (t1, t2) → v entonces return v
+//     v := freshSupply()
+//     table[(t1, t2)] := v
+//     return v
+//
+// La tabla de correspondencias se mantiene globalmente durante la
+// recursión para que múltiples ocurrencias del mismo desacuerdo
+// reciban la misma fresh var. Sin esta tabla obtendríamos una
+// generalización menos específica (e.g., au(p(a,a), p(b,b)) daría
+// p(X, Y) en vez de p(X, X)).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultFreshSupply = defaultFreshSupply;
+exports.antiUnify = antiUnify;
+const term_utils_1 = require("./term-utils");
+/**
+ * Fuente default de variables frescas: _g0, _g1, _g2, …
+ *
+ * Se devuelve una NUEVA instancia por llamada para evitar estado
+ * compartido entre invocaciones de antiUnify.
+ */
+function defaultFreshSupply(prefix = '_g') {
+    let counter = 0;
+    return () => `${prefix}${counter++}`;
+}
+/**
+ * Anti-unification de dos términos.
+ *
+ * Devuelve el lgg (least general generalization) junto con las
+ * sustituciones de izquierda y derecha que reconstruyen los
+ * términos originales.
+ *
+ * Complejidad: O(|t1| + |t2|) tiempo si la tabla se implementa con
+ * hashing O(1). Usamos `termKey` que serializa, así que es
+ * O((|t1| + |t2|)·k) donde k es el tamaño del subtérmino más grande
+ * que aparezca en un desacuerdo.
+ */
+function antiUnify(t1, t2, freshSupply) {
+    const supply = freshSupply ?? defaultFreshSupply();
+    // Tabla de desacuerdos: clave canónica "t1║t2" → nombre de var fresca.
+    const table = new Map();
+    // Sustituciones de salida: para cada fresh var, qué término iba en
+    // cada lado.
+    const substLeft = new Map();
+    const substRight = new Map();
+    // Orden de introducción de las fresh vars (para `variables`).
+    const variables = [];
+    const generalization = antiUnifyAux(t1, t2, table, substLeft, substRight, variables, supply);
+    return { generalization, substLeft, substRight, variables };
+}
+/**
+ * Núcleo recursivo del algoritmo. Se mantiene recursivo (no iterativo)
+ * porque la mayoría de términos en la práctica son superficiales y la
+ * recursión sigue la estructura del término más pequeño.
+ *
+ * Si en algún momento aparecen términos patológicamente profundos,
+ * habría que reescribirlo con un stack explícito siguiendo el patrón
+ * de `mapTerm` en term-rewriting/term-utils.ts.
+ */
+function antiUnifyAux(t1, t2, table, substLeft, substRight, variables, supply) {
+    // Caso base: estructuralmente iguales → la generalización es el
+    // término mismo, sin nuevas variables.
+    if ((0, term_utils_1.termEquals)(t1, t2))
+        return t1;
+    // Misma "cabeza" (mismo símbolo, misma aridad, mismo kind func/const)
+    // → recursamos argumento a argumento.
+    if (sameHead(t1, t2)) {
+        const args1 = t1.args ?? [];
+        const args2 = t2.args ?? [];
+        // sameHead garantiza aridad igual.
+        const newArgs = new Array(args1.length);
+        for (let i = 0; i < args1.length; i++) {
+            const a1 = args1[i];
+            const a2 = args2[i];
+            if (a1 === undefined || a2 === undefined) {
+                // Imposible si sameHead pasó, pero el chequeo apacigua a TS
+                // bajo noUncheckedIndexedAccess.
+                throw new Error('antiUnify: aridad inconsistente tras sameHead check');
+            }
+            newArgs[i] = antiUnifyAux(a1, a2, table, substLeft, substRight, variables, supply);
+        }
+        if (t1.kind === 'const') {
+            // const con args=[] ya cayó en termEquals; si llegamos aquí con
+            // kind=const es porque ambos tienen mismo nombre y 0 args, lo
+            // que ya implicaría termEquals=true. Defensa por si llega un
+            // const con args>0 mal construido.
+            return { kind: 'const', name: t1.name };
+        }
+        return { kind: 'func', name: t1.name, args: newArgs };
+    }
+    // Desacuerdo: pares distintos. Reutilizamos la fresh var si ya
+    // habíamos visto este par; de lo contrario generamos una nueva.
+    const key = pairKey(t1, t2);
+    const existing = table.get(key);
+    if (existing !== undefined) {
+        return { kind: 'var', name: existing };
+    }
+    const fresh = supply();
+    table.set(key, fresh);
+    substLeft.set(fresh, t1);
+    substRight.set(fresh, t2);
+    variables.push(fresh);
+    return { kind: 'var', name: fresh };
+}
+/**
+ * ¿t1 y t2 comparten la misma "cabeza" (símbolo + aridad + kind no-var)?
+ *
+ * Variables NUNCA tienen cabeza común con otra cosa: el caso `var, var`
+ * con mismos nombres ya lo absorbe `termEquals` arriba; con nombres
+ * distintos es un desacuerdo legítimo. Un `var` contra `func/const`
+ * también es desacuerdo (la variable es más general).
+ */
+function sameHead(t1, t2) {
+    if (t1.kind === 'var' || t2.kind === 'var')
+        return false;
+    // Tratamos const como func(name, []) para comparar aridad.
+    if (t1.name !== t2.name)
+        return false;
+    const a1 = t1.args ?? [];
+    const a2 = t2.args ?? [];
+    if (a1.length !== a2.length)
+        return false;
+    // Si los kinds difieren (func vs const) pero la aridad es 0 y los
+    // nombres coinciden, todavía lo aceptamos como "misma cabeza" para
+    // ser tolerantes con clientes que mezclen ambas convenciones.
+    // Pero antes de aceptar, exigimos que si difieren los kinds, la
+    // aridad sea 0 — un `const` con args no debería existir.
+    if (t1.kind !== t2.kind && a1.length > 0)
+        return false;
+    return true;
+}
+/**
+ * Clave canónica para un par (t1, t2) usada en la tabla de
+ * desacuerdos. Usamos un separador que no puede aparecer en
+ * `termKey` para evitar colisiones.
+ */
+function pairKey(t1, t2) {
+    return `${(0, term_utils_1.termKey)(t1)}║${(0, term_utils_1.termKey)(t2)}`;
+}
+//# sourceMappingURL=anti-unify.js.map

package/dist/runtime/anti-unification/anti-unify.js.map

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

package/dist/runtime/anti-unification/index.d.ts

@@ -0,0 +1,6 @@
+export type { Term, AntiUnificationResult, FreshSupply } from './types';
+export { antiUnify, defaultFreshSupply } from './anti-unify';
+export { termEquals, termKey, varsOf, applySubst, termSize, v, f, c } from './term-utils';
+export { antiUnifyMany, antiUnifyManyDetailed, generalizationOrder } from './many';
+export type { AntiUnificationManyResult } from './many';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/anti-unification/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/anti-unification/index.ts"],"names":[],"mappings":"AAIA,YAAY,EAAE,IAAI,EAAE,qBAAqB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAExE,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAE7D,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,cAAc,CAAC;AAE1F,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,QAAQ,CAAC;AAEnF,YAAY,EAAE,yBAAyB,EAAE,MAAM,QAAQ,CAAC"}

package/dist/runtime/anti-unification/index.js

@@ -0,0 +1,23 @@
+"use strict";
+// ============================================================
+// ST Anti-Unification — Barrel de exportaciones
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generalizationOrder = exports.antiUnifyManyDetailed = exports.antiUnifyMany = exports.c = exports.f = exports.v = exports.termSize = exports.applySubst = exports.varsOf = exports.termKey = exports.termEquals = exports.defaultFreshSupply = exports.antiUnify = void 0;
+var anti_unify_1 = require("./anti-unify");
+Object.defineProperty(exports, "antiUnify", { enumerable: true, get: function () { return anti_unify_1.antiUnify; } });
+Object.defineProperty(exports, "defaultFreshSupply", { enumerable: true, get: function () { return anti_unify_1.defaultFreshSupply; } });
+var term_utils_1 = require("./term-utils");
+Object.defineProperty(exports, "termEquals", { enumerable: true, get: function () { return term_utils_1.termEquals; } });
+Object.defineProperty(exports, "termKey", { enumerable: true, get: function () { return term_utils_1.termKey; } });
+Object.defineProperty(exports, "varsOf", { enumerable: true, get: function () { return term_utils_1.varsOf; } });
+Object.defineProperty(exports, "applySubst", { enumerable: true, get: function () { return term_utils_1.applySubst; } });
+Object.defineProperty(exports, "termSize", { enumerable: true, get: function () { return term_utils_1.termSize; } });
+Object.defineProperty(exports, "v", { enumerable: true, get: function () { return term_utils_1.v; } });
+Object.defineProperty(exports, "f", { enumerable: true, get: function () { return term_utils_1.f; } });
+Object.defineProperty(exports, "c", { enumerable: true, get: function () { return term_utils_1.c; } });
+var many_1 = require("./many");
+Object.defineProperty(exports, "antiUnifyMany", { enumerable: true, get: function () { return many_1.antiUnifyMany; } });
+Object.defineProperty(exports, "antiUnifyManyDetailed", { enumerable: true, get: function () { return many_1.antiUnifyManyDetailed; } });
+Object.defineProperty(exports, "generalizationOrder", { enumerable: true, get: function () { return many_1.generalizationOrder; } });
+//# sourceMappingURL=index.js.map

package/dist/runtime/anti-unification/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime/anti-unification/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,gDAAgD;AAChD,+DAA+D;;;AAI/D,2CAA6D;AAApD,uGAAA,SAAS,OAAA;AAAE,gHAAA,kBAAkB,OAAA;AAEtC,2CAA0F;AAAjF,wGAAA,UAAU,OAAA;AAAE,qGAAA,OAAO,OAAA;AAAE,oGAAA,MAAM,OAAA;AAAE,wGAAA,UAAU,OAAA;AAAE,sGAAA,QAAQ,OAAA;AAAE,+FAAA,CAAC,OAAA;AAAE,+FAAA,CAAC,OAAA;AAAE,+FAAA,CAAC,OAAA;AAEnE,+BAAmF;AAA1E,qGAAA,aAAa,OAAA;AAAE,6GAAA,qBAAqB,OAAA;AAAE,2GAAA,mBAAmB,OAAA"}

package/dist/runtime/anti-unification/many.d.ts

@@ -0,0 +1,49 @@
+import type { AntiUnificationResult, FreshSupply, Term } from './types';
+import { applySubst } from './term-utils';
+/**
+ * Variante "detailed" del n-way lgg.
+ *
+ * Devuelve la generalización y un array `substs` de longitud n tal
+ * que substs[i] aplicada al generalization reproduce el término i.
+ */
+export interface AntiUnificationManyResult {
+    generalization: Term;
+    substs: Map<string, Term>[];
+    variables: string[];
+}
+/**
+ * Anti-unification n-aria. Reduce con la versión binaria.
+ *
+ * Para n=0 lanza error (no hay generalización sensata).
+ * Para n=1 devuelve el término sin variables nuevas.
+ */
+export declare function antiUnifyMany(terms: Term[], freshSupply?: FreshSupply): AntiUnificationResult;
+/**
+ * Versión "detailed" — devuelve las n sustituciones independientes.
+ *
+ * Esta es la forma más útil para clientes que quieren ver cómo se
+ * instancia cada uno de los n términos desde la generalización.
+ */
+export declare function antiUnifyManyDetailed(terms: Term[], freshSupply?: FreshSupply): AntiUnificationManyResult;
+/**
+ * Orden de generalidad entre dos términos.
+ *
+ * Definición: g1 ≤ g2 ⇔ existe sustitución σ con σ(g1) = g2.
+ * Es decir, g1 es MÁS GENERAL que g2 (g2 es una instancia de g1).
+ *
+ * Resultados:
+ *   - -1  si g1 es ESTRICTAMENTE más general que g2 (g1 < g2 en
+ *         generalidad inversa — equivalente: σ(g1)=g2 pero no
+ *         σ'(g2)=g1).
+ *   -  0  si son equivalentes módulo renombre (cada uno instancia
+ *         del otro vía sustitución de variables).
+ *   - +1  si g2 es estrictamente más general que g1.
+ *   - null si son INCOMPARABLES (no hay σ en ningún sentido).
+ *
+ * Nota: la convención del usuario en la spec es
+ *   generalizationOrder(X, f(X)) → -1 (X más general).
+ * Esto es coherente: X es más general que f(X), y devolvemos -1.
+ */
+export declare function generalizationOrder(g1: Term, g2: Term): -1 | 0 | 1 | null;
+export { applySubst };
+//# sourceMappingURL=many.d.ts.map