@stevenvo780/st-lang 4.2.0 → 4.3.0

package/dist/runtime/term-rewriting/knuth-bendix.js

@@ -0,0 +1,196 @@
+"use strict";
+// ============================================================
+// ST Term Rewriting — Knuth-Bendix Completion
+// ============================================================
+//
+// KB completion transforma un conjunto de ecuaciones E en un TRS
+// terminante y confluente (cuando existe). Procedimiento clásico:
+//
+//   1. Orientar cada ecuación s = t en regla l → r usando una
+//      reducción ordering > (LPO acá).
+//   2. Inter-reducir las reglas (simplify) para mantener minimalidad.
+//   3. Calcular critical pairs.
+//   4. Por cada CP (a, b):
+//        a' = normalize(a)
+//        b' = normalize(b)
+//        si a' ≡ b' → joinable, descartar.
+//        si no → agregar como nueva regla orientada.
+//   5. Volver al paso 2 hasta que no haya nuevos CPs ⇒ completed.
+//
+// KB es **semi-decidible**: puede no terminar (orientar nuevas
+// ecuaciones puede no ser posible, o el espacio crecer sin cota).
+// Por eso exigimos `maxSteps`.
+//
+// Implementación: estrategia simple "outer loop", no la versión
+// optimizada de Huet con prioridades. Suficiente para teorías
+// pequeñas de testing (grupos, conmutatividad-a-medias, etc.).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orient = orient;
+exports.knuthBendixCompletion = knuthBendixCompletion;
+exports.makeTRS = makeTRS;
+const term_utils_1 = require("./term-utils");
+const rewrite_1 = require("./rewrite");
+const critical_pairs_1 = require("./critical-pairs");
+const lpo_1 = require("./lpo");
+/**
+ * Orienta una ecuación s = t a regla l → r usando LPO.
+ *
+ * - Si s >LPO t: devuelve s → t.
+ * - Si t >LPO s: devuelve t → s.
+ * - Si son incomparables: null (KB falla aquí, el caller debe abortar
+ *   o pedir al user una precedencia distinta).
+ * - Si son iguales: ecuación trivial, devuelve null sin error.
+ */
+function orient(s, t, precedence) {
+    const cmp = (0, lpo_1.lpoCompare)(s, t, precedence);
+    if (cmp === 'eq')
+        return null;
+    if (cmp === 'gt')
+        return { lhs: s, rhs: t };
+    if (cmp === 'lt')
+        return { lhs: t, rhs: s };
+    // incomparable
+    return null;
+}
+/**
+ * ¿La regla `r` es subsumida (redundante) dada la lista `rules`?
+ *
+ * Una regla l → r es redundante si normalize(l, rules \ {r}) ya
+ * llega a r. En particular, si su LHS es reducible por otra regla,
+ * la regla nunca dispara y puede eliminarse.
+ */
+function isRedundant(rule, rules) {
+    const others = rules.filter((x) => x !== rule);
+    const reducedLhs = (0, rewrite_1.normalize)(rule.lhs, others, 1000);
+    if (!(0, term_utils_1.termEquals)(reducedLhs, rule.lhs))
+        return true;
+    const reducedRhs = (0, rewrite_1.normalize)(rule.rhs, rules, 1000);
+    if ((0, term_utils_1.termEquals)(reducedLhs, reducedRhs)) {
+        // ambos lados convergen sin la regla
+        return true;
+    }
+    return false;
+}
+/**
+ * Inter-reduce: simplifica los RHS y elimina reglas redundantes.
+ */
+function interReduce(rules) {
+    let current = rules.slice();
+    let changed = true;
+    let guard = 0;
+    while (changed && guard++ < 50) {
+        changed = false;
+        // Normalizar RHS de cada regla con las demás
+        const nextRules = [];
+        for (const r of current) {
+            const others = current.filter((x) => x !== r);
+            const newRhs = (0, rewrite_1.normalize)(r.rhs, others, 1000);
+            if (!(0, term_utils_1.termEquals)(newRhs, r.rhs)) {
+                changed = true;
+                nextRules.push({ lhs: r.lhs, rhs: newRhs });
+            }
+            else {
+                nextRules.push(r);
+            }
+        }
+        // Quitar reglas redundantes
+        const filtered = nextRules.filter((r) => !isRedundant(r, nextRules));
+        if (filtered.length !== nextRules.length)
+            changed = true;
+        current = filtered;
+    }
+    return current;
+}
+/**
+ * Detecta duplicados sintácticos.
+ */
+function ruleAlreadyPresent(rule, rules) {
+    return rules.some((r) => (0, term_utils_1.termEquals)(r.lhs, rule.lhs) && (0, term_utils_1.termEquals)(r.rhs, rule.rhs));
+}
+/**
+ * Knuth-Bendix completion.
+ *
+ * `initialRules` se interpretan como ecuaciones orientadas. La
+ * orientación inicial se respeta si ya está bien dirigida según
+ * la precedencia; si no, se re-orienta.
+ *
+ * Devuelve un `KBResult` con:
+ *   - `completed: true` si convergió.
+ *   - `completed: false` si se excedió `maxSteps` o un CP no-joinable
+ *     no pudo orientarse (LPO incomparable).
+ */
+function knuthBendixCompletion(initialRules, opts = {}) {
+    const precedence = opts.precedence ?? new Map();
+    const maxSteps = opts.maxSteps ?? 100;
+    // Re-orientar las reglas iniciales con LPO. Si una ecuación no
+    // es trivial (lhs ≠ rhs) y LPO no la decide, KB falla de
+    // inmediato: la orientabilidad de las ecuaciones iniciales es un
+    // pre-requisito.
+    let rules = [];
+    for (const r of initialRules) {
+        if ((0, term_utils_1.termEquals)(r.lhs, r.rhs))
+            continue; // ecuación trivial
+        const oriented = orient(r.lhs, r.rhs, precedence);
+        if (oriented === null) {
+            return {
+                trs: { rules },
+                completed: false,
+                criticalPairs: 0,
+                steps: 0,
+            };
+        }
+        if (!ruleAlreadyPresent(oriented, rules)) {
+            rules.push(oriented);
+        }
+    }
+    let cpCount = 0;
+    let step;
+    for (step = 0; step < maxSteps; step++) {
+        rules = interReduce(rules);
+        const cps = (0, critical_pairs_1.allCriticalPairs)(rules);
+        cpCount += cps.length;
+        let addedAny = false;
+        for (const cp of cps) {
+            const a = (0, rewrite_1.normalize)(cp.lhs, rules);
+            const b = (0, rewrite_1.normalize)(cp.rhs, rules);
+            if ((0, term_utils_1.termEquals)(a, b))
+                continue; // joinable
+            const oriented = orient(a, b, precedence);
+            if (oriented === null) {
+                // CP no joinable y no orientable ⇒ KB falla.
+                return {
+                    trs: { rules },
+                    completed: false,
+                    criticalPairs: cpCount,
+                    steps: step + 1,
+                };
+            }
+            if (!ruleAlreadyPresent(oriented, rules)) {
+                rules.push(oriented);
+                addedAny = true;
+            }
+        }
+        if (!addedAny) {
+            // No se añadió ninguna regla nueva ⇒ converged.
+            return {
+                trs: { rules },
+                completed: true,
+                criticalPairs: cpCount,
+                steps: step + 1,
+            };
+        }
+    }
+    return {
+        trs: { rules },
+        completed: false,
+        criticalPairs: cpCount,
+        steps: step,
+    };
+}
+/**
+ * Sugar: construye un TRS plano.
+ */
+function makeTRS(rules) {
+    return { rules };
+}
+//# sourceMappingURL=knuth-bendix.js.map

package/dist/runtime/term-rewriting/knuth-bendix.js.map

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

package/dist/runtime/term-rewriting/lpo.d.ts

@@ -0,0 +1,17 @@
+import type { Term } from './types';
+export type LPOComparison = 'gt' | 'lt' | 'eq' | 'inc';
+/**
+ * LPO comparison "rica": incluye 'inc' (incomparable).
+ */
+export declare function lpoCompare(t1: Term, t2: Term, precedence: Map<string, number>): LPOComparison;
+/**
+ * API pública compacta: devuelve -1 | 0 | 1.
+ *
+ *  -1 si t1 <LPO t2
+ *   0 si iguales o incomparables
+ *  +1 si t1 >LPO t2
+ *
+ * Para distinguir incomparable vs igual, usar `lpoCompare`.
+ */
+export declare function lpo(t1: Term, t2: Term, precedence: Map<string, number>): -1 | 0 | 1;
+//# sourceMappingURL=lpo.d.ts.map

package/dist/runtime/term-rewriting/lpo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lpo.d.ts","sourceRoot":"","sources":["../../../src/runtime/term-rewriting/lpo.ts"],"names":[],"mappings":"AA6BA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAGpC,MAAM,MAAM,aAAa,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC;AAsBvD;;GAEG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,aAAa,CA4D7F;AAwBD;;;;;;;;GAQG;AACH,wBAAgB,GAAG,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAKnF"}

package/dist/runtime/term-rewriting/lpo.js

@@ -0,0 +1,158 @@
+"use strict";
+// ============================================================
+// ST Term Rewriting — Lexicographic Path Order (LPO)
+// ============================================================
+//
+// LPO es una de las técnicas estándar para probar terminación de
+// TRSs. Dada una precedencia >F sobre símbolos de función,
+// extiende a un orden bien-fundado >LPO sobre términos.
+//
+// Definición (Dershowitz, 1982):
+//
+//   s = f(s₁..sₙ) >LPO t  sii  alguno de:
+//
+//   (LPO1) algún sᵢ ≥LPO t
+//   (LPO2) t = g(t₁..tₘ),  f >F g,  y  s >LPO tⱼ para todo j
+//   (LPO3) t = f(t₁..tₘ),  s >LPO tⱼ para todo j, y
+//          (s₁..sₙ) >LPO,lex (t₁..tₘ)
+//
+//   Variables: x >LPO t  sii  x = t y t es variable (caso trivial).
+//   En general, una variable no domina a nada que no sea ella misma.
+//
+// Devolvemos -1 / 0 / 1 estilo comparator:
+//   -1  si t1 <LPO t2
+//    0  si t1 ≡LPO t2 (estructuralmente iguales)
+//   +1  si t1 >LPO t2
+//   NaN (sentinel = 0 acá) si incomparables — convención: 0 también.
+//
+// Para diferenciar "iguales" de "incomparables" exponemos `lpoCompare`
+// que devuelve `'gt' | 'lt' | 'eq' | 'inc'`. `lpo` colapsa inc→0.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lpoCompare = lpoCompare;
+exports.lpo = lpo;
+const term_utils_1 = require("./term-utils");
+function precOf(name, precedence) {
+    return precedence.get(name) ?? 0;
+}
+/**
+ * Comparación de precedencia de símbolos de función.
+ *
+ * Si ambos tienen la misma prioridad, compara por nombre para
+ * romper empates de forma determinista (necesario para que LPO
+ * sea total sobre términos cerrados).
+ */
+function compareSymbols(a, b, precedence) {
+    const pa = precOf(a, precedence);
+    const pb = precOf(b, precedence);
+    if (pa > pb)
+        return 1;
+    if (pa < pb)
+        return -1;
+    if (a === b)
+        return 0;
+    return a < b ? -1 : 1;
+}
+/**
+ * LPO comparison "rica": incluye 'inc' (incomparable).
+ */
+function lpoCompare(t1, t2, precedence) {
+    if ((0, term_utils_1.termEquals)(t1, t2))
+        return 'eq';
+    // Caso variable
+    if (t1.kind === 'var' && t2.kind === 'var') {
+        return 'inc'; // variables distintas son incomparables
+    }
+    if (t1.kind === 'var') {
+        // x >LPO t solo si x ocurre en t (improper subterm). Estándar:
+        // x ≮LPO t para todo t excepto x. Devolvemos 'lt' si x aparece en t2.
+        return occursVar(t1.name, t2) ? 'lt' : 'inc';
+    }
+    if (t2.kind === 'var') {
+        return occursVar(t2.name, t1) ? 'gt' : 'inc';
+    }
+    // Ambos func: t1 = f(s₁..sₙ), t2 = g(t₁..tₘ)
+    const f = t1.name;
+    const g = t2.name;
+    const ss = t1.args;
+    const ts = t2.args;
+    // (LPO1): algún sᵢ ≥LPO t2 ⇒ t1 >LPO t2
+    for (const si of ss) {
+        const cmp = lpoCompare(si, t2, precedence);
+        if (cmp === 'gt' || cmp === 'eq')
+            return 'gt';
+    }
+    // Simétrico para t2: si algún tⱼ ≥LPO t1, entonces t2 >LPO t1
+    for (const tj of ts) {
+        const cmp = lpoCompare(tj, t1, precedence);
+        if (cmp === 'gt' || cmp === 'eq')
+            return 'lt';
+    }
+    const cmpFG = compareSymbols(f, g, precedence);
+    // (LPO2): f >F g y t1 >LPO tⱼ para todo j
+    if (cmpFG === 1) {
+        if (ts.every((tj) => lpoCompare(t1, tj, precedence) === 'gt'))
+            return 'gt';
+        return 'inc';
+    }
+    if (cmpFG === -1) {
+        if (ss.every((si) => lpoCompare(t2, si, precedence) === 'gt'))
+            return 'lt';
+        return 'inc';
+    }
+    // (LPO3): f = g (mismo símbolo y misma aridad, si no son incomparables)
+    if (ss.length !== ts.length)
+        return 'inc';
+    // s >LPO tⱼ para todo j
+    const allGt = ts.every((tj) => lpoCompare(t1, tj, precedence) === 'gt');
+    if (!allGt) {
+        // chequear simétrico para 'lt'
+        const allLt = ss.every((si) => lpoCompare(t2, si, precedence) === 'gt');
+        if (allLt)
+            return lexCompare(ts, ss, precedence) === 'gt' ? 'lt' : 'inc';
+        return 'inc';
+    }
+    // Comparación lexicográfica de argumentos
+    return lexCompare(ss, ts, precedence);
+}
+/**
+ * Comparación lexicográfica de tuplas de términos.
+ */
+function lexCompare(ss, ts, precedence) {
+    const n = Math.min(ss.length, ts.length);
+    for (let i = 0; i < n; i++) {
+        const si = ss[i];
+        const ti = ts[i];
+        if (si === undefined || ti === undefined)
+            continue;
+        const cmp = lpoCompare(si, ti, precedence);
+        if (cmp === 'eq')
+            continue;
+        return cmp;
+    }
+    if (ss.length === ts.length)
+        return 'eq';
+    return ss.length > ts.length ? 'gt' : 'lt';
+}
+function occursVar(name, t) {
+    if (t.kind === 'var')
+        return t.name === name;
+    return t.args.some((a) => occursVar(name, a));
+}
+/**
+ * API pública compacta: devuelve -1 | 0 | 1.
+ *
+ *  -1 si t1 <LPO t2
+ *   0 si iguales o incomparables
+ *  +1 si t1 >LPO t2
+ *
+ * Para distinguir incomparable vs igual, usar `lpoCompare`.
+ */
+function lpo(t1, t2, precedence) {
+    const r = lpoCompare(t1, t2, precedence);
+    if (r === 'gt')
+        return 1;
+    if (r === 'lt')
+        return -1;
+    return 0;
+}
+//# sourceMappingURL=lpo.js.map

package/dist/runtime/term-rewriting/lpo.js.map

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

package/dist/runtime/term-rewriting/rewrite.d.ts

@@ -0,0 +1,44 @@
+import type { RewriteRule, Term } from './types';
+/**
+ * Intenta aplicar exactamente un paso de reescritura.
+ *
+ * Devuelve el término reducido o null si no hay redex.
+ *
+ * Política de selección:
+ *   - Recorre t en pre-order (raíz primero, luego argumentos).
+ *   - Para cada nodo prueba las reglas en orden.
+ *   - El primer match aplica.
+ */
+export declare function rewriteStep(t: Term, rules: RewriteRule[]): Term | null;
+/**
+ * Normaliza t aplicando reglas hasta punto fijo.
+ *
+ * @param maxSteps  Cota de seguridad para sistemas no terminantes.
+ *                  Si se excede, devuelve el último estado alcanzado.
+ *
+ * Nota: la confluencia se asume responsabilidad del caller — si el
+ * TRS no es confluente, distintas estrategias pueden dar distintas
+ * FN. Acá fijamos leftmost-outermost.
+ */
+export declare function normalize(t: Term, rules: RewriteRule[], maxSteps?: number): Term;
+/**
+ * Lista todas las posiciones (caminos) en t. Una posición es un
+ * array de índices: [] = raíz, [0] = primer argumento, [0, 1] =
+ * segundo argumento del primer argumento, etc.
+ *
+ * Útil para enumerar redexes y para calcular critical pairs.
+ */
+export declare function allPositions(t: Term, prefix?: number[]): number[][];
+/**
+ * Obtiene el subtérmino en la posición indicada.
+ * Devuelve null si la posición no existe.
+ */
+export declare function subtermAt(t: Term, pos: readonly number[]): Term | null;
+/**
+ * Reemplaza el subtérmino en la posición indicada por `replacement`.
+ *
+ * Devuelve un término nuevo (sin mutar t). Si la posición no existe,
+ * devuelve t sin cambios.
+ */
+export declare function replaceAt(t: Term, pos: readonly number[], replacement: Term): Term;
+//# sourceMappingURL=rewrite.d.ts.map

package/dist/runtime/term-rewriting/rewrite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rewrite.d.ts","sourceRoot":"","sources":["../../../src/runtime/term-rewriting/rewrite.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAcjD;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,GAAG,IAAI,GAAG,IAAI,CAOtE;AAqCD;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,EAAE,QAAQ,GAAE,MAAc,GAAG,IAAI,CAYvF;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAE,MAAM,EAAO,GAAG,MAAM,EAAE,EAAE,CAiBvE;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,GAAG,IAAI,CAStE;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,SAAS,MAAM,EAAE,EAAE,WAAW,EAAE,IAAI,GAAG,IAAI,CAyBlF"}

package/dist/runtime/term-rewriting/rewrite.js

@@ -0,0 +1,189 @@
+"use strict";
+// ============================================================
+// ST Term Rewriting — Reescritura y normalización
+// ============================================================
+//
+// Aplicación de reglas l → r sobre un término t.
+//
+// Estrategia: leftmost-outermost. Se recorre t en pre-order;
+// para cada subtérmino se intenta match contra el LHS de alguna
+// regla. El primer match gana. Esto es suficiente para sistemas
+// confluentes (todas las estrategias llegan a la misma FN), y
+// para los terminantes garantiza progreso.
+//
+// `normalize` itera `rewriteStep` hasta punto fijo o hasta
+// `maxSteps` (default 10_000) — la cota evita ciclos cuando el
+// sistema no es terminante.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rewriteStep = rewriteStep;
+exports.normalize = normalize;
+exports.allPositions = allPositions;
+exports.subtermAt = subtermAt;
+exports.replaceAt = replaceAt;
+const term_utils_1 = require("./term-utils");
+/**
+ * Cota de tamaño máximo del término durante normalización.
+ *
+ * Si el sistema no es terminante, el término puede crecer sin parar
+ * y aún antes de agotar `maxSteps` puede agotar la pila al recorrer.
+ * Esta cota corta el bucle cuando el término supera un tamaño "absurdo"
+ * (rara vez un término legítimo de KB supera ~10k nodos en teorías
+ * pequeñas).
+ */
+const MAX_TERM_SIZE = 5000;
+/**
+ * Intenta aplicar exactamente un paso de reescritura.
+ *
+ * Devuelve el término reducido o null si no hay redex.
+ *
+ * Política de selección:
+ *   - Recorre t en pre-order (raíz primero, luego argumentos).
+ *   - Para cada nodo prueba las reglas en orden.
+ *   - El primer match aplica.
+ */
+function rewriteStep(t, rules) {
+    // Iterativo: busca el redex outermost-leftmost recorriendo el
+    // árbol en pre-order con stack explícito. Cuando encuentra un
+    // redex, replaceAt reconstruye el árbol con la sustitución.
+    const found = findRedex(t, rules);
+    if (found === null)
+        return null;
+    return replaceAt(t, found.position, found.replacement);
+}
+/**
+ * Búsqueda del primer redex en pre-order (outermost-leftmost).
+ * Iterativo para soportar términos profundos.
+ */
+function findRedex(t, rules) {
+    // Stack de (node, position) en orden de DFS pre-order.
+    const stack = [{ node: t, pos: [] }];
+    while (stack.length > 0) {
+        const frame = stack.pop();
+        if (frame === undefined)
+            break;
+        const { node, pos } = frame;
+        // Intentar reglas en este nodo.
+        for (const rule of rules) {
+            const subst = (0, term_utils_1.match)(rule.lhs, node);
+            if (subst !== null) {
+                return { position: pos, replacement: (0, term_utils_1.applySubst)(rule.rhs, subst) };
+            }
+        }
+        // Si no hay match, push children en orden inverso para que el
+        // leftmost (índice 0) se procese primero al pop.
+        if (node.kind === 'func') {
+            for (let i = node.args.length - 1; i >= 0; i--) {
+                const child = node.args[i];
+                if (child === undefined)
+                    continue;
+                stack.push({ node: child, pos: [...pos, i] });
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Normaliza t aplicando reglas hasta punto fijo.
+ *
+ * @param maxSteps  Cota de seguridad para sistemas no terminantes.
+ *                  Si se excede, devuelve el último estado alcanzado.
+ *
+ * Nota: la confluencia se asume responsabilidad del caller — si el
+ * TRS no es confluente, distintas estrategias pueden dar distintas
+ * FN. Acá fijamos leftmost-outermost.
+ */
+function normalize(t, rules, maxSteps = 10000) {
+    let current = t;
+    for (let i = 0; i < maxSteps; i++) {
+        // Guard contra divergencia: si el término supera MAX_TERM_SIZE
+        // asumimos que el sistema no es terminante en esta dirección
+        // y devolvemos el último estado.
+        if ((0, term_utils_1.termSize)(current) > MAX_TERM_SIZE)
+            return current;
+        const next = rewriteStep(current, rules);
+        if (next === null)
+            return current;
+        current = next;
+    }
+    return current;
+}
+/**
+ * Lista todas las posiciones (caminos) en t. Una posición es un
+ * array de índices: [] = raíz, [0] = primer argumento, [0, 1] =
+ * segundo argumento del primer argumento, etc.
+ *
+ * Útil para enumerar redexes y para calcular critical pairs.
+ */
+function allPositions(t, prefix = []) {
+    // Iterativo, BFS por orden estable (raíz, luego hijos en orden 0..n).
+    const out = [];
+    const queue = [{ node: t, pos: prefix.slice() }];
+    while (queue.length > 0) {
+        const head = queue.shift();
+        if (head === undefined)
+            break;
+        out.push(head.pos);
+        if (head.node.kind === 'func') {
+            for (let i = 0; i < head.node.args.length; i++) {
+                const a = head.node.args[i];
+                if (a === undefined)
+                    continue;
+                queue.push({ node: a, pos: [...head.pos, i] });
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Obtiene el subtérmino en la posición indicada.
+ * Devuelve null si la posición no existe.
+ */
+function subtermAt(t, pos) {
+    let cur = t;
+    for (const idx of pos) {
+        if (cur.kind !== 'func')
+            return null;
+        const next = cur.args[idx];
+        if (next === undefined)
+            return null;
+        cur = next;
+    }
+    return cur;
+}
+/**
+ * Reemplaza el subtérmino en la posición indicada por `replacement`.
+ *
+ * Devuelve un término nuevo (sin mutar t). Si la posición no existe,
+ * devuelve t sin cambios.
+ */
+function replaceAt(t, pos, replacement) {
+    if (pos.length === 0)
+        return replacement;
+    // Caminamos hasta el nodo padre del target, luego reconstruimos
+    // de vuelta. Iterativo.
+    const path = [t];
+    let cur = t;
+    for (let i = 0; i < pos.length; i++) {
+        if (cur.kind !== 'func')
+            return t; // posición inválida
+        const idx = pos[i];
+        const child = cur.args[idx];
+        if (child === undefined)
+            return t;
+        cur = child;
+        path.push(cur);
+    }
+    // path[i] = nodo en profundidad i; path[len-1] = target a reemplazar.
+    // Reconstruimos desde la hoja.
+    let acc = replacement;
+    for (let i = pos.length - 1; i >= 0; i--) {
+        const parent = path[i];
+        if (parent === undefined || parent.kind !== 'func')
+            return t;
+        const newArgs = parent.args.slice();
+        newArgs[pos[i]] = acc;
+        acc = { kind: 'func', name: parent.name, args: newArgs };
+    }
+    return acc;
+}
+//# sourceMappingURL=rewrite.js.map

package/dist/runtime/term-rewriting/rewrite.js.map

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