@stevenvo780/st-lang 4.3.0 → 4.5.0

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

@@ -0,0 +1,185 @@
+"use strict";
+// ============================================================
+// ST Anti-Unification — n-way lgg
+// ============================================================
+//
+// La anti-unification se generaliza a n términos plegando con la
+// versión binaria:
+//
+//   lgg(t1, t2, ..., tn) = lgg(lgg(...lgg(t1, t2)..., tn-1), tn)
+//
+// Plotkin demostró que lgg es asociativo y conmutativo módulo
+// renombre de variables: el orden del pliegue no cambia la
+// generalización resultante (salvo nombres de variables).
+//
+// Sin embargo, las substLeft/substRight intermedias acumulan
+// información, así que para el resultado n-ario devolvemos:
+//
+//   - generalization: el lgg de los n términos.
+//   - variables:      las fresh vars introducidas.
+//   - substLeft, substRight: aquí pierden sentido binario; en el
+//     resultado n-ario los reusamos para el PRIMER y ÚLTIMO término
+//     respectivamente. Para acceso completo, los clientes deberían
+//     re-derivar `match(generalization, ti)` para cada i.
+//
+// Para conservar acceso completo a las n sustituciones, exponemos
+// también `antiUnifyManyDetailed` que devuelve un array de mapas.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applySubst = void 0;
+exports.antiUnifyMany = antiUnifyMany;
+exports.antiUnifyManyDetailed = antiUnifyManyDetailed;
+exports.generalizationOrder = generalizationOrder;
+const anti_unify_1 = require("./anti-unify");
+const term_utils_1 = require("./term-utils");
+Object.defineProperty(exports, "applySubst", { enumerable: true, get: function () { return term_utils_1.applySubst; } });
+/**
+ * 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.
+ */
+function antiUnifyMany(terms, freshSupply) {
+    if (terms.length === 0) {
+        throw new Error('antiUnifyMany: array vacío, no hay lgg');
+    }
+    const supply = freshSupply ?? (0, anti_unify_1.defaultFreshSupply)();
+    const first = terms[0];
+    if (first === undefined) {
+        throw new Error('antiUnifyMany: índice 0 indefinido');
+    }
+    if (terms.length === 1) {
+        return {
+            generalization: first,
+            substLeft: new Map(),
+            substRight: new Map(),
+            variables: [],
+        };
+    }
+    // Pliegue izquierdo binario. Reusamos el mismo supply para que
+    // las fresh vars tengan numeración monótona.
+    let acc = (0, anti_unify_1.antiUnify)(first, terms[1], supply);
+    for (let i = 2; i < terms.length; i++) {
+        const ti = terms[i];
+        if (ti === undefined) {
+            throw new Error(`antiUnifyMany: índice ${i} indefinido`);
+        }
+        const next = (0, anti_unify_1.antiUnify)(acc.generalization, ti, supply);
+        acc = {
+            generalization: next.generalization,
+            substLeft: acc.substLeft, // del primer término — se preserva semántica original.
+            substRight: next.substRight, // del último término.
+            variables: next.variables,
+        };
+    }
+    // `variables` de acc puede no incluir las vars de pasos anteriores
+    // que sobrevivieron en la generalización final. Re-derivamos desde
+    // las vars que aparecen en `acc.generalization`.
+    const vars = Array.from((0, term_utils_1.varsOf)(acc.generalization));
+    return { ...acc, variables: vars };
+}
+/**
+ * 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.
+ */
+function antiUnifyManyDetailed(terms, freshSupply) {
+    const lgg = antiUnifyMany(terms, freshSupply);
+    const substs = [];
+    // Para cada término ti, hacemos matching de la generalización
+    // contra ti. La generalización siempre matchea (es el lgg) y la
+    // sustitución es única.
+    for (const ti of terms) {
+        const m = matchGeneralization(lgg.generalization, ti);
+        if (m === null) {
+            // Inconsistencia: no debería ocurrir si antiUnifyMany es
+            // correcto. Lanzamos para no esconder bugs.
+            throw new Error('antiUnifyManyDetailed: matching de la generalización falló (bug interno)');
+        }
+        substs.push(m);
+    }
+    return {
+        generalization: lgg.generalization,
+        substs,
+        variables: lgg.variables,
+    };
+}
+/**
+ * Matching unidireccional: σ(pattern) = target. Variables del
+ * pattern se ligan; el target se trata como término concreto.
+ *
+ * Es una versión local porque term-utils del módulo no exporta
+ * matching (lo evitamos para no duplicar el módulo de unify).
+ */
+function matchGeneralization(pattern, target) {
+    const subst = new Map();
+    const stack = [[pattern, target]];
+    while (stack.length > 0) {
+        const pair = stack.pop();
+        if (pair === undefined)
+            break;
+        const [p, q] = pair;
+        if (p.kind === 'var') {
+            const existing = subst.get(p.name);
+            if (existing !== undefined) {
+                if (!(0, term_utils_1.termEquals)(existing, q))
+                    return null;
+                continue;
+            }
+            subst.set(p.name, q);
+            continue;
+        }
+        // p es func o const; q debe ser del mismo "head".
+        if (q.kind === 'var')
+            return null;
+        if (p.name !== q.name)
+            return null;
+        const pa = p.args ?? [];
+        const qa = q.args ?? [];
+        if (pa.length !== qa.length)
+            return null;
+        for (let i = 0; i < pa.length; i++) {
+            const pi = pa[i];
+            const qi = qa[i];
+            if (pi === undefined || qi === undefined)
+                return null;
+            stack.push([pi, qi]);
+        }
+    }
+    return subst;
+}
+/**
+ * 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.
+ */
+function generalizationOrder(g1, g2) {
+    const sigma12 = matchGeneralization(g1, g2); // g1 → g2 ?
+    const sigma21 = matchGeneralization(g2, g1); // g2 → g1 ?
+    if (sigma12 !== null && sigma21 !== null)
+        return 0;
+    if (sigma12 !== null) {
+        // σ(g1) = g2; ahora distingue si es un renombre puro (igualdad
+        // módulo nombres) o una instanciación estricta. Como sigma21 es
+        // null, no es renombre — es estricta.
+        return -1;
+    }
+    if (sigma21 !== null)
+        return 1;
+    return null;
+}
+//# sourceMappingURL=many.js.map

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

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

package/dist/runtime/anti-unification/term-utils.d.ts

@@ -0,0 +1,40 @@
+import type { Term } from './types';
+/**
+ * Igualdad estructural de términos (iterativa, soporta árboles
+ * profundos sin stack overflow).
+ *
+ * Tolera la dualidad const/func-con-args=[]: un `const a` y un
+ * `func a` con args=[] cuentan como iguales para no penalizar al
+ * cliente que mezcle ambas convenciones.
+ */
+export declare function termEquals(a: Term, b: Term): boolean;
+/**
+ * Serialización canónica de un término. Usada para comparar pares
+ * (t1, t2) en la tabla de desacuerdos del algoritmo de Plotkin.
+ *
+ * Usa caracteres no-alfanuméricos como separadores para evitar
+ * ambigüedades con nombres que contengan paréntesis o comas.
+ */
+export declare function termKey(t: Term): string;
+/**
+ * Conjunto de variables que aparecen en t (iterativo).
+ */
+export declare function varsOf(t: Term, acc?: Set<string>): Set<string>;
+/**
+ * Aplica una sustitución a un término (no compone cadenas — la
+ * sustitución es plana, no recursiva, porque las generadas por
+ * antiUnify son siempre con vars frescas a la izquierda y términos
+ * cerrados-respecto-a-vars-frescas a la derecha).
+ */
+export declare function applySubst(t: Term, subst: Map<string, Term>): Term;
+/**
+ * Tamaño del término (cantidad de nodos).
+ */
+export declare function termSize(t: Term): number;
+/** Variable. */
+export declare function v(name: string): Term;
+/** Constante (sin args). */
+export declare function c(name: string): Term;
+/** Aplicación de función. */
+export declare function f(name: string, ...args: Term[]): Term;
+//# sourceMappingURL=term-utils.d.ts.map

package/dist/runtime/anti-unification/term-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"term-utils.d.ts","sourceRoot":"","sources":["../../../src/runtime/anti-unification/term-utils.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAEpC;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,OAAO,CAyBpD;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM,CAcvC;AAsBD;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,GAAE,GAAG,CAAC,MAAM,CAAa,GAAG,GAAG,CAAC,MAAM,CAAC,CAYzE;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,IAAI,CAiBlE;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM,CAMxC;AAMD,gBAAgB;AAChB,wBAAgB,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAEpC;AAED,4BAA4B;AAC5B,wBAAgB,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAEpC;AAED,6BAA6B;AAC7B,wBAAgB,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,CAErD"}

package/dist/runtime/anti-unification/term-utils.js

@@ -0,0 +1,173 @@
+"use strict";
+// ============================================================
+// ST Anti-Unification — Utilidades de términos
+// ============================================================
+//
+// Helpers locales al módulo de anti-unification. Se mantienen
+// separados de term-rewriting/term-utils porque el shape de Term
+// es distinto (admite `kind: 'const'` con `args?` opcional).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.termEquals = termEquals;
+exports.termKey = termKey;
+exports.varsOf = varsOf;
+exports.applySubst = applySubst;
+exports.termSize = termSize;
+exports.v = v;
+exports.c = c;
+exports.f = f;
+/**
+ * Igualdad estructural de términos (iterativa, soporta árboles
+ * profundos sin stack overflow).
+ *
+ * Tolera la dualidad const/func-con-args=[]: un `const a` y un
+ * `func a` con args=[] cuentan como iguales para no penalizar al
+ * cliente que mezcle ambas convenciones.
+ */
+function termEquals(a, b) {
+    const stack = [[a, b]];
+    while (stack.length > 0) {
+        const pair = stack.pop();
+        if (pair === undefined)
+            break;
+        const [x, y] = pair;
+        // Variables: igualdad por nombre.
+        if (x.kind === 'var' || y.kind === 'var') {
+            if (x.kind !== y.kind)
+                return false;
+            if (x.name !== y.name)
+                return false;
+            continue;
+        }
+        // func/const con mismo nombre y misma aridad.
+        if (x.name !== y.name)
+            return false;
+        const xa = x.args ?? [];
+        const ya = y.args ?? [];
+        if (xa.length !== ya.length)
+            return false;
+        for (let i = 0; i < xa.length; i++) {
+            const xi = xa[i];
+            const yi = ya[i];
+            if (xi === undefined || yi === undefined)
+                return false;
+            stack.push([xi, yi]);
+        }
+    }
+    return true;
+}
+/**
+ * Serialización canónica de un término. Usada para comparar pares
+ * (t1, t2) en la tabla de desacuerdos del algoritmo de Plotkin.
+ *
+ * Usa caracteres no-alfanuméricos como separadores para evitar
+ * ambigüedades con nombres que contengan paréntesis o comas.
+ */
+function termKey(t) {
+    // Iterativo con encoding postorden simple. Para términos típicos
+    // el costo es lineal en el tamaño del término.
+    const out = [];
+    walkPreorder(t, (node) => {
+        if (node.kind === 'var') {
+            out.push(`§v⟨${node.name}⟩`);
+        }
+        else if (node.kind === 'const') {
+            out.push(`§c⟨${node.name}⟩`);
+        }
+        else {
+            out.push(`§f⟨${node.name}/${(node.args ?? []).length}⟩`);
+        }
+    });
+    return out.join('');
+}
+/**
+ * Recorrido preorden iterativo de un término.
+ */
+function walkPreorder(t, visit) {
+    const stack = [t];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node === undefined)
+            break;
+        visit(node);
+        if (node.kind === 'func') {
+            const args = node.args ?? [];
+            // Push en orden inverso para que el recorrido salga izq→der.
+            for (let i = args.length - 1; i >= 0; i--) {
+                const a = args[i];
+                if (a !== undefined)
+                    stack.push(a);
+            }
+        }
+    }
+}
+/**
+ * Conjunto de variables que aparecen en t (iterativo).
+ */
+function varsOf(t, acc = new Set()) {
+    const stack = [t];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node === undefined)
+            break;
+        if (node.kind === 'var') {
+            acc.add(node.name);
+        }
+        else if (node.kind === 'func') {
+            for (const a of node.args ?? [])
+                stack.push(a);
+        }
+    }
+    return acc;
+}
+/**
+ * Aplica una sustitución a un término (no compone cadenas — la
+ * sustitución es plana, no recursiva, porque las generadas por
+ * antiUnify son siempre con vars frescas a la izquierda y términos
+ * cerrados-respecto-a-vars-frescas a la derecha).
+ */
+function applySubst(t, subst) {
+    if (t.kind === 'var') {
+        const bound = subst.get(t.name);
+        if (bound === undefined)
+            return t;
+        return bound;
+    }
+    if (t.kind === 'const')
+        return t;
+    const args = t.args ?? [];
+    const newArgs = new Array(args.length);
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === undefined) {
+            throw new Error('applySubst: arg undefined en términos func');
+        }
+        newArgs[i] = applySubst(a, subst);
+    }
+    return { kind: 'func', name: t.name, args: newArgs };
+}
+/**
+ * Tamaño del término (cantidad de nodos).
+ */
+function termSize(t) {
+    let n = 0;
+    walkPreorder(t, () => {
+        n++;
+    });
+    return n;
+}
+// ---------------------------------------------------------------
+// Constructores azúcar para tests y uso directo.
+// ---------------------------------------------------------------
+/** Variable. */
+function v(name) {
+    return { kind: 'var', name };
+}
+/** Constante (sin args). */
+function c(name) {
+    return { kind: 'const', name };
+}
+/** Aplicación de función. */
+function f(name, ...args) {
+    return { kind: 'func', name, args };
+}
+//# sourceMappingURL=term-utils.js.map

package/dist/runtime/anti-unification/term-utils.js.map

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

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

@@ -0,0 +1,41 @@
+/**
+ * Término de primer orden para anti-unification.
+ *
+ * - `var`:   variable de unificación.
+ * - `func`:  símbolo de función con aridad implícita por len(args).
+ * - `const`: constante (sin args). Equivalente a `func` con args=[]
+ *            pero distinguible sintácticamente.
+ */
+export interface Term {
+    kind: 'var' | 'func' | 'const';
+    name: string;
+    args?: Term[];
+}
+/**
+ * Resultado de anti-unification.
+ *
+ * - `generalization`: el lgg (least general generalization) — el
+ *   término más específico tal que ambos t1 y t2 son instancias.
+ * - `substLeft`:  σ_L tal que σ_L(generalization) = t1.
+ * - `substRight`: σ_R tal que σ_R(generalization) = t2.
+ * - `variables`:  variables frescas introducidas en `generalization`
+ *   por desacuerdos (en orden de aparición).
+ *
+ * Invariante: para toda v ∈ variables, substLeft.get(v) y
+ * substRight.get(v) están definidas y son distintas estructuralmente
+ * (si fueran iguales, no habría hecho falta introducir la fresh var).
+ */
+export interface AntiUnificationResult {
+    generalization: Term;
+    substLeft: Map<string, Term>;
+    substRight: Map<string, Term>;
+    variables: string[];
+}
+/**
+ * Fuente de variables frescas. Una función que cada vez que se
+ * invoca devuelve un nombre nuevo (no usado previamente).
+ *
+ * Default (cuando no se pasa): genera `_g0`, `_g1`, `_g2`, …
+ */
+export type FreshSupply = () => string;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/runtime/anti-unification/types.ts"],"names":[],"mappings":"AAwBA;;;;;;;GAOG;AACH,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC;CACf;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,qBAAqB;IACpC,cAAc,EAAE,IAAI,CAAC;IACrB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC7B,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC9B,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,MAAM,CAAC"}

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

@@ -0,0 +1,26 @@
+"use strict";
+// ============================================================
+// ST Anti-Unification — Tipos públicos
+// ============================================================
+//
+// Anti-unification (también: lgg = least general generalization,
+// most-specific generalization) es el dual de la unificación.
+//
+// Dados dos términos t1, t2, calcula el TERM más específico g
+// tal que existen sustituciones σ1, σ2 con:
+//
+//   σ1(g) = t1      y      σ2(g) = t2
+//
+// Aplicaciones:
+//   - Machine learning de patrones (Plotkin 1970, Reynolds 1970).
+//   - Descubrimiento de generalizations en demostraciones.
+//   - Inducción por ejemplo en programación lógica.
+//   - Síntesis de lemas en sistemas de prueba.
+//
+// La firma del módulo usa un Term ligeramente más expresivo que
+// term-rewriting/types.ts: admite `const` explícitamente además
+// de `var` y `func`. En la práctica `const` es azúcar para `func`
+// con `args: []`, pero se mantiene como kind separado por claridad
+// pedagógica (el módulo es referenciado desde ejemplos educativos).
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/runtime/anti-unification/types.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,uCAAuC;AACvC,+DAA+D;AAC/D,EAAE;AACF,iEAAiE;AACjE,8DAA8D;AAC9D,EAAE;AACF,8DAA8D;AAC9D,4CAA4C;AAC5C,EAAE;AACF,sCAAsC;AACtC,EAAE;AACF,gBAAgB;AAChB,kEAAkE;AAClE,2DAA2D;AAC3D,oDAAoD;AACpD,+CAA+C;AAC/C,EAAE;AACF,gEAAgE;AAChE,gEAAgE;AAChE,kEAAkE;AAClE,mEAAmE;AACnE,oEAAoE"}

package/dist/runtime/csp/ac3.d.ts

@@ -0,0 +1,20 @@
+import type { CSP } from './types';
+/**
+ * Aplica AC-3 sobre una copia de los dominios del CSP.
+ * Devuelve { consistent, reducedDomains }: si `consistent` es false,
+ * el CSP es UNSAT por consistencia de arco (algún dominio quedó vacío).
+ *
+ * La firma deja los dominios originales intactos: el caller decide si
+ * adoptar `reducedDomains` o conservar los originales.
+ */
+export declare function ac3<V, D>(csp: CSP<V, D>): {
+    consistent: boolean;
+    reducedDomains: Map<V, D[]>;
+};
+/**
+ * Helper público para uso en backtracking incremental: aplica AC-3
+ * sobre un set de dominios ya provisto (mutación in-place permitida)
+ * y devuelve `true` si los dominios siguen consistentes.
+ */
+export declare function ac3InPlace<V, D>(csp: CSP<V, D>, domains: Map<V, D[]>): boolean;
+//# sourceMappingURL=ac3.d.ts.map

package/dist/runtime/csp/ac3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ac3.d.ts","sourceRoot":"","sources":["../../../src/runtime/csp/ac3.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,GAAG,EAAc,MAAM,SAAS,CAAC;AA8D/C;;;;;;;GAOG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,EACtB,GAAG,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,GACb;IACD,UAAU,EAAE,OAAO,CAAC;IACpB,cAAc,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;CAC7B,CAqCA;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,OAAO,CA2B9E"}