@stevenvo780/st-lang 4.3.0 → 4.4.0

package/dist/runtime/markov-logic/parser.js

@@ -0,0 +1,264 @@
+"use strict";
+// ============================================================
+// Markov Logic — Mini parser FOL (sin cuantificadores explícitos)
+// ============================================================
+//
+// Gramática soportada (las variables libres se cuantifican
+// universalmente al groundear):
+//
+//   formula  := implication
+//   implication := disjunction ('→' | '->' disjunction)*   (right-assoc)
+//   disjunction := conjunction ('∨' | '|' | '||' conjunction)*
+//   conjunction := unary ('∧' | '&' | '&&' unary)*
+//   unary       := ('¬' | '!') unary | atom
+//   atom        := '(' formula ')' | predicate
+//   predicate   := Ident '(' arg (',' arg)* ')'
+//   arg         := Ident
+//
+// Convención de variables/constantes:
+//   - identificadores en minúscula → variables (lower-cased first char)
+//   - identificadores en mayúscula → constantes
+//
+// Esta gramática alcanza para Smoking, Friends, transitividad, etc.
+// No soporta cuantificadores explícitos `∀ ∃`; la cuantificación es
+// implícitamente universal sobre todas las variables libres.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFOL = parseFOL;
+exports.freeVariables = freeVariables;
+exports.isVariable = isVariable;
+function parseFOL(input) {
+    const tokens = tokenize(input);
+    const parser = new Parser(tokens, input);
+    const node = parser.parseImplication();
+    parser.expectEOF();
+    return node;
+}
+/** Devuelve las variables libres (lowercase) que aparecen en `node`. */
+function freeVariables(node) {
+    const out = new Set();
+    walk(node, out);
+    return Array.from(out).sort();
+}
+function walk(node, acc) {
+    switch (node.kind) {
+        case 'atom':
+            for (const a of node.args)
+                if (isVariable(a))
+                    acc.add(a);
+            return;
+        case 'not':
+            walk(node.arg, acc);
+            return;
+        case 'and':
+        case 'or':
+        case 'implies':
+            walk(node.left, acc);
+            walk(node.right, acc);
+            return;
+    }
+}
+function isVariable(name) {
+    if (name.length === 0)
+        return false;
+    const c = name.charCodeAt(0);
+    // 'a'..'z' → variable
+    return c >= 97 && c <= 122;
+}
+function tokenize(input) {
+    const out = [];
+    let i = 0;
+    const n = input.length;
+    while (i < n) {
+        const c = input[i];
+        if (c === undefined)
+            break;
+        // whitespace
+        if (c === ' ' || c === '\t' || c === '\n' || c === '\r') {
+            i++;
+            continue;
+        }
+        // single chars
+        if (c === '(') {
+            out.push({ kind: 'LPAREN', text: c, pos: i });
+            i++;
+            continue;
+        }
+        if (c === ')') {
+            out.push({ kind: 'RPAREN', text: c, pos: i });
+            i++;
+            continue;
+        }
+        if (c === ',') {
+            out.push({ kind: 'COMMA', text: c, pos: i });
+            i++;
+            continue;
+        }
+        if (c === '¬' || c === '!' || c === '~') {
+            out.push({ kind: 'NOT', text: c, pos: i });
+            i++;
+            continue;
+        }
+        if (c === '∧') {
+            out.push({ kind: 'AND', text: c, pos: i });
+            i++;
+            continue;
+        }
+        if (c === '&') {
+            // accept "&" or "&&"
+            let text = '&';
+            i++;
+            if (input[i] === '&') {
+                text = '&&';
+                i++;
+            }
+            out.push({ kind: 'AND', text, pos: i });
+            continue;
+        }
+        if (c === '∨') {
+            out.push({ kind: 'OR', text: c, pos: i });
+            i++;
+            continue;
+        }
+        if (c === '|') {
+            let text = '|';
+            i++;
+            if (input[i] === '|') {
+                text = '||';
+                i++;
+            }
+            out.push({ kind: 'OR', text, pos: i });
+            continue;
+        }
+        if (c === '→') {
+            out.push({ kind: 'IMPLIES', text: c, pos: i });
+            i++;
+            continue;
+        }
+        if (c === '-') {
+            if (input[i + 1] === '>') {
+                out.push({ kind: 'IMPLIES', text: '->', pos: i });
+                i += 2;
+                continue;
+            }
+            throw new Error(`Carácter inesperado '-' en posición ${i}`);
+        }
+        // identifier: [A-Za-z_][A-Za-z0-9_]*
+        if (isIdentStart(c)) {
+            const start = i;
+            i++;
+            while (i < n) {
+                const ch = input[i];
+                if (ch !== undefined && isIdentCont(ch))
+                    i++;
+                else
+                    break;
+            }
+            out.push({ kind: 'IDENT', text: input.slice(start, i), pos: start });
+            continue;
+        }
+        throw new Error(`Carácter inesperado '${c}' en posición ${i}`);
+    }
+    out.push({ kind: 'EOF', text: '', pos: n });
+    return out;
+}
+function isIdentStart(c) {
+    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c === '_';
+}
+function isIdentCont(c) {
+    return isIdentStart(c) || (c >= '0' && c <= '9');
+}
+// ── Recursive-descent parser ──────────────────────────────────
+class Parser {
+    tokens;
+    src;
+    idx = 0;
+    constructor(tokens, src) {
+        this.tokens = tokens;
+        this.src = src;
+    }
+    peek() {
+        const t = this.tokens[this.idx];
+        if (!t)
+            throw new Error('Fin de tokens inesperado');
+        return t;
+    }
+    consume() {
+        const t = this.peek();
+        this.idx++;
+        return t;
+    }
+    expect(kind) {
+        const t = this.peek();
+        if (t.kind !== kind) {
+            throw new Error(`Esperaba ${kind} en posición ${t.pos}, encontré ${t.kind} ('${t.text}'). Fórmula: "${this.src}"`);
+        }
+        return this.consume();
+    }
+    expectEOF() {
+        const t = this.peek();
+        if (t.kind !== 'EOF') {
+            throw new Error(`Tokens sobrantes desde posición ${t.pos} en fórmula: "${this.src}"`);
+        }
+    }
+    // implication is right-associative: A → B → C ≡ A → (B → C)
+    parseImplication() {
+        const left = this.parseDisjunction();
+        if (this.peek().kind === 'IMPLIES') {
+            this.consume();
+            const right = this.parseImplication();
+            return { kind: 'implies', left, right };
+        }
+        return left;
+    }
+    parseDisjunction() {
+        let left = this.parseConjunction();
+        while (this.peek().kind === 'OR') {
+            this.consume();
+            const right = this.parseConjunction();
+            left = { kind: 'or', left, right };
+        }
+        return left;
+    }
+    parseConjunction() {
+        let left = this.parseUnary();
+        while (this.peek().kind === 'AND') {
+            this.consume();
+            const right = this.parseUnary();
+            left = { kind: 'and', left, right };
+        }
+        return left;
+    }
+    parseUnary() {
+        if (this.peek().kind === 'NOT') {
+            this.consume();
+            return { kind: 'not', arg: this.parseUnary() };
+        }
+        return this.parseAtom();
+    }
+    parseAtom() {
+        const t = this.peek();
+        if (t.kind === 'LPAREN') {
+            this.consume();
+            const inner = this.parseImplication();
+            this.expect('RPAREN');
+            return inner;
+        }
+        if (t.kind === 'IDENT') {
+            const pred = this.consume().text;
+            this.expect('LPAREN');
+            const args = [];
+            // accept zero-arity gracefully: P()
+            if (this.peek().kind !== 'RPAREN') {
+                args.push(this.expect('IDENT').text);
+                while (this.peek().kind === 'COMMA') {
+                    this.consume();
+                    args.push(this.expect('IDENT').text);
+                }
+            }
+            this.expect('RPAREN');
+            return { kind: 'atom', predicate: pred, args };
+        }
+        throw new Error(`Esperaba un átomo en posición ${t.pos}, encontré ${t.kind} ('${t.text}')`);
+    }
+}
+//# sourceMappingURL=parser.js.map

package/dist/runtime/markov-logic/parser.js.map

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

package/dist/runtime/markov-logic/types.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Fórmula de la teoría MLN.
+ *
+ * `formula` es una cadena FOL con literales `Pred(args)` y
+ * conectores `∧`, `∨`, `→`, `¬` (o sus variantes ASCII `&`, `|`, `->`,
+ * `!`). Las variables se infieren por convención: identificadores que
+ * empiezan en minúscula son variables; los que empiezan en mayúscula
+ * son constantes (cerradas).
+ *
+ * `weight` es un peso real. `Infinity` significa hard constraint: la
+ * fórmula DEBE satisfacerse en todo mundo con probabilidad no nula.
+ */
+export interface MLNFormula {
+    formula: string;
+    weight: number;
+}
+/**
+ * Teoría MLN completa: fórmulas + dominios tipados de constantes +
+ * declaración de predicados.
+ *
+ * `constants[t]` es el conjunto de constantes del tipo `t`.
+ * `predicates[i].types` declara el tipo de cada argumento del
+ * predicado `predicates[i].name`.
+ *
+ * Para teorías untyped, basta usar un único tipo (por ejemplo
+ * `"Person"`) y declarar todos los predicados sobre él.
+ */
+export interface MLNTheory {
+    formulas: MLNFormula[];
+    constants: Record<string, string[]>;
+    predicates: Array<{
+        name: string;
+        types: string[];
+    }>;
+}
+/**
+ * Mundo posible: asignación booleana sobre ground atoms.
+ *
+ * Las claves son strings canónicos `"Pred(arg1,arg2,...)"` (sin
+ * espacios). Atoms ausentes se interpretan como `false` (closed-world
+ * assumption opcional, usualmente activada en MLN).
+ */
+export interface MLNWorld {
+    groundAtoms: Record<string, boolean>;
+}
+/**
+ * Resultado de groundear una fórmula sobre el universo de constantes.
+ *
+ * Cada `GroundedFormula` representa una instancia concreta (sin
+ * variables libres) de la fórmula original. `violations(world)`
+ * devuelve `0` si el mundo SATISFACE la instancia, `1` si la viola.
+ * Esto facilita componer el peso del mundo: cada `violations > 0`
+ * resta `w · violations` del log-score.
+ */
+export interface GroundedFormula {
+    groundFormula: string;
+    weight: number;
+    violations: (world: MLNWorld) => number;
+    /** Atoms que aparecen en esta ground formula (útil para Gibbs). */
+    atoms: string[];
+    /** Predicado: ¿la fórmula se satisface en `world`? */
+    satisfied: (world: MLNWorld) => boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/runtime/markov-logic/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/runtime/markov-logic/types.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACpC,UAAU,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;CACtD;AAED;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ;IACvB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,MAAM,CAAC;IACxC,mEAAmE;IACnE,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,sDAAsD;IACtD,SAAS,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,OAAO,CAAC;CACzC"}

package/dist/runtime/markov-logic/types.js

@@ -0,0 +1,17 @@
+"use strict";
+// ============================================================
+// Markov Logic Networks — Types
+// ============================================================
+//
+// Una Markov Logic Network (MLN) combina lógica de primer orden
+// con redes de Markov. Cada fórmula `F` lleva un peso real `w`.
+// La distribución sobre mundos posibles `W` es:
+//
+//   P(W) = (1/Z) · exp( Σ_i  w_i · n_i(W) )
+//
+// donde `n_i(W)` cuenta las grounding instances de `F_i` SATISFECHAS
+// en `W`. Pesos +∞ equivalen a restricciones duras (hard constraints).
+//
+// Referencia: Richardson & Domingos, "Markov Logic Networks" (2006).
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/runtime/markov-logic/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/runtime/markov-logic/types.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,gCAAgC;AAChC,+DAA+D;AAC/D,EAAE;AACF,gEAAgE;AAChE,gEAAgE;AAChE,gDAAgD;AAChD,EAAE;AACF,4CAA4C;AAC5C,EAAE;AACF,qEAAqE;AACrE,uEAAuE;AACvE,EAAE;AACF,qEAAqE"}

package/dist/runtime/pi-calculus/congruence.d.ts

@@ -0,0 +1,15 @@
+import type { PiProcess } from './types';
+/**
+ * Decide si dos procesos son estructuralmente congruentes (módulo los
+ * axiomas listados arriba + α-equivalencia).
+ *
+ * Cobertura intencional:
+ *   - Conmutatividad/asociatividad/nil de | y +.
+ *   - Renaming de binders.
+ *   - `(νc) 0 ≡ 0`.
+ * Cobertura intencionalmente limitada (excede el scope mínimo del runtime):
+ *   - Scope extrusion `(νc)(P|Q) ≡ P | (νc) Q`.
+ *   - Unfold de replicación.
+ */
+export declare function structuralCongruence(a: PiProcess, b: PiProcess): boolean;
+//# sourceMappingURL=congruence.d.ts.map

package/dist/runtime/pi-calculus/congruence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"congruence.d.ts","sourceRoot":"","sources":["../../../src/runtime/pi-calculus/congruence.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAuJzC;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,OAAO,CAMxE"}

package/dist/runtime/pi-calculus/congruence.js

@@ -0,0 +1,271 @@
+"use strict";
+// ============================================================
+// π-calculus — congruencia estructural ≡.
+// ============================================================
+// Axiomas estándar:
+//   P | 0 ≡ P                    (nil unitario de |)
+//   P | Q ≡ Q | P                (conmutatividad de |)
+//   (P | Q) | R ≡ P | (Q | R)    (asociatividad de |)
+//   P + 0 ≡ P
+//   P + Q ≡ Q + P
+//   (P + Q) + R ≡ P + (Q + R)
+//   (νc)(νd) P ≡ (νd)(νc) P      (intercambio de scopes)
+//   (νc) 0 ≡ 0                   (canal vacío sin uso)
+//   (νc) (P | Q) ≡ P | (νc) Q    si c ∉ fn(P)   (scope extrusion)
+//   !P ≡ P | !P                  (unfold de replicación, lo dejamos como opcional)
+//   α-conversion sobre binders
+//
+// Implementación: normalizamos ambos procesos a una "forma canónica"
+// (flatten de paralelas y sumas + ordenamiento estructural + drop de
+// `0` unitarios) y luego comparamos por igualdad sintáctica módulo
+// α-renaming sobre binders.
+//
+// No es decisión completa de ≡ (la equivalencia es indecidible en
+// general en presencia de replicación), pero cubre los axiomas
+// básicos suficientes para los tests y propiedades esperadas.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.structuralCongruence = structuralCongruence;
+const names_1 = require("./names");
+/**
+ * Normaliza un proceso a forma canónica para comparar ≡.
+ *
+ *  - Aplana `parallel` y `choice` asociativos en listas, descarta `0`s.
+ *  - Ordena las listas con un orden estructural total y reconstruye en
+ *    forma asociativa derecha canónica.
+ *  - Refresca nombres ligados a una secuencia determinista
+ *    (`#bn0`, `#bn1`, ...) en post-orden para que α-equivalentes
+ *    colapsen.
+ */
+function canonical(p, counter) {
+    // 1. α-normalizar binders en post-orden.
+    const renamed = renameBindersCanonical(p, counter);
+    // 2. flatten + sort + drop nil.
+    return normalize(renamed);
+}
+function renameBindersCanonical(p, counter) {
+    switch (p.kind) {
+        case 'nil':
+            return p;
+        case 'input': {
+            const cont = renameBindersCanonical(p.cont, counter);
+            const fresh = `#bn${counter.n++}`;
+            const renamed = (0, names_1.alphaRename)(cont, p.bind, fresh);
+            return { kind: 'input', channel: p.channel, bind: fresh, cont: renamed };
+        }
+        case 'output':
+            return {
+                kind: 'output',
+                channel: p.channel,
+                value: p.value,
+                cont: renameBindersCanonical(p.cont, counter),
+            };
+        case 'parallel':
+            return {
+                kind: 'parallel',
+                left: renameBindersCanonical(p.left, counter),
+                right: renameBindersCanonical(p.right, counter),
+            };
+        case 'choice':
+            return {
+                kind: 'choice',
+                left: renameBindersCanonical(p.left, counter),
+                right: renameBindersCanonical(p.right, counter),
+            };
+        case 'new': {
+            const body = renameBindersCanonical(p.body, counter);
+            const fresh = `#bn${counter.n++}`;
+            const renamed = (0, names_1.alphaRename)(body, p.channel, fresh);
+            return { kind: 'new', channel: fresh, body: renamed };
+        }
+        case 'replication':
+            return { kind: 'replication', body: renameBindersCanonical(p.body, counter) };
+        case 'match':
+            return {
+                kind: 'match',
+                left: p.left,
+                right: p.right,
+                cont: renameBindersCanonical(p.cont, counter),
+            };
+    }
+}
+function normalize(p) {
+    switch (p.kind) {
+        case 'nil':
+            return p;
+        case 'input':
+            return { kind: 'input', channel: p.channel, bind: p.bind, cont: normalize(p.cont) };
+        case 'output':
+            return {
+                kind: 'output',
+                channel: p.channel,
+                value: p.value,
+                cont: normalize(p.cont),
+            };
+        case 'parallel': {
+            const parts = flattenParallel(p)
+                .map(normalize)
+                .filter((q) => q.kind !== 'nil');
+            if (parts.length === 0)
+                return { kind: 'nil' };
+            if (parts.length === 1)
+                return parts[0];
+            parts.sort((a, b) => structKey(a).localeCompare(structKey(b)));
+            return parts.reduceRight((acc, q) => ({ kind: 'parallel', left: q, right: acc }));
+        }
+        case 'choice': {
+            const parts = flattenChoice(p)
+                .map(normalize)
+                .filter((q) => q.kind !== 'nil');
+            if (parts.length === 0)
+                return { kind: 'nil' };
+            if (parts.length === 1)
+                return parts[0];
+            parts.sort((a, b) => structKey(a).localeCompare(structKey(b)));
+            return parts.reduceRight((acc, q) => ({ kind: 'choice', left: q, right: acc }));
+        }
+        case 'new': {
+            const body = normalize(p.body);
+            // (νc) 0 ≡ 0
+            if (body.kind === 'nil')
+                return { kind: 'nil' };
+            return { kind: 'new', channel: p.channel, body };
+        }
+        case 'replication':
+            return { kind: 'replication', body: normalize(p.body) };
+        case 'match':
+            return {
+                kind: 'match',
+                left: p.left,
+                right: p.right,
+                cont: normalize(p.cont),
+            };
+    }
+}
+function flattenParallel(p) {
+    if (p.kind !== 'parallel')
+        return [p];
+    return [...flattenParallel(p.left), ...flattenParallel(p.right)];
+}
+function flattenChoice(p) {
+    if (p.kind !== 'choice')
+        return [p];
+    return [...flattenChoice(p.left), ...flattenChoice(p.right)];
+}
+/**
+ * Serialización estructural estable para usar como clave de
+ * ordenamiento. Determinista bajo igualdad sintáctica.
+ */
+function structKey(p) {
+    switch (p.kind) {
+        case 'nil':
+            return '0';
+        case 'input':
+            return `in(${p.channel},${p.bind},${structKey(p.cont)})`;
+        case 'output':
+            return `out(${p.channel},${p.value},${structKey(p.cont)})`;
+        case 'parallel':
+            return `par(${structKey(p.left)},${structKey(p.right)})`;
+        case 'choice':
+            return `sum(${structKey(p.left)},${structKey(p.right)})`;
+        case 'new':
+            return `new(${p.channel},${structKey(p.body)})`;
+        case 'replication':
+            return `rep(${structKey(p.body)})`;
+        case 'match':
+            return `mat(${p.left},${p.right},${structKey(p.cont)})`;
+    }
+}
+/**
+ * Decide si dos procesos son estructuralmente congruentes (módulo los
+ * axiomas listados arriba + α-equivalencia).
+ *
+ * Cobertura intencional:
+ *   - Conmutatividad/asociatividad/nil de | y +.
+ *   - Renaming de binders.
+ *   - `(νc) 0 ≡ 0`.
+ * Cobertura intencionalmente limitada (excede el scope mínimo del runtime):
+ *   - Scope extrusion `(νc)(P|Q) ≡ P | (νc) Q`.
+ *   - Unfold de replicación.
+ */
+function structuralCongruence(a, b) {
+    // Aplicamos scope extrusion repetidamente como pre-paso, después
+    // normalizamos y comparamos por structKey.
+    const A = canonical(extrudeScopes(a), { n: 0 });
+    const B = canonical(extrudeScopes(b), { n: 0 });
+    return structKey(A) === structKey(B);
+}
+/**
+ * Aplica scope extrusion donde sea posible: `(νc)(P|Q) ≡ P | (νc) Q`
+ * cuando `c ∉ fn(P)`. No es óptimo pero alcanza para los axiomas.
+ */
+function extrudeScopes(p) {
+    switch (p.kind) {
+        case 'nil':
+            return p;
+        case 'input':
+            return { kind: 'input', channel: p.channel, bind: p.bind, cont: extrudeScopes(p.cont) };
+        case 'output':
+            return {
+                kind: 'output',
+                channel: p.channel,
+                value: p.value,
+                cont: extrudeScopes(p.cont),
+            };
+        case 'parallel':
+            return {
+                kind: 'parallel',
+                left: extrudeScopes(p.left),
+                right: extrudeScopes(p.right),
+            };
+        case 'choice':
+            return {
+                kind: 'choice',
+                left: extrudeScopes(p.left),
+                right: extrudeScopes(p.right),
+            };
+        case 'new': {
+            const body = extrudeScopes(p.body);
+            if (body.kind === 'parallel') {
+                const fnL = (0, names_1.freeNames)(body.left);
+                const fnR = (0, names_1.freeNames)(body.right);
+                const leftFree = !fnL.has(p.channel);
+                const rightFree = !fnR.has(p.channel);
+                if (leftFree && rightFree) {
+                    // Canal restringido pero no usado en ninguna rama: descártalo.
+                    return { kind: 'parallel', left: body.left, right: body.right };
+                }
+                if (leftFree) {
+                    // Empujar (νc) hacia la rama derecha.
+                    return {
+                        kind: 'parallel',
+                        left: body.left,
+                        right: extrudeScopes({ kind: 'new', channel: p.channel, body: body.right }),
+                    };
+                }
+                if (rightFree) {
+                    return {
+                        kind: 'parallel',
+                        left: extrudeScopes({ kind: 'new', channel: p.channel, body: body.left }),
+                        right: body.right,
+                    };
+                }
+            }
+            // Caso especial: (νc) que liga un canal nunca usado en el cuerpo.
+            if (!(0, names_1.freeNames)(body).has(p.channel)) {
+                return body;
+            }
+            return { kind: 'new', channel: p.channel, body };
+        }
+        case 'replication':
+            return { kind: 'replication', body: extrudeScopes(p.body) };
+        case 'match':
+            return {
+                kind: 'match',
+                left: p.left,
+                right: p.right,
+                cont: extrudeScopes(p.cont),
+            };
+    }
+}
+//# sourceMappingURL=congruence.js.map