@stevenvo780/st-lang 4.3.0 → 4.4.0

package/dist/profiles/mu-calculus/ctl-translate.js

@@ -0,0 +1,181 @@
+"use strict";
+// ============================================================
+// CTL → modal μ-calculus translator
+// ============================================================
+// Encoding clásico (Emerson 1990 — "Temporal and Modal Logic"):
+//
+//   EX φ        ≡ ◇φ
+//   AX φ        ≡ □φ
+//   EF φ        ≡ μX. φ ∨ ◇X
+//   AF φ        ≡ μX. φ ∨ □X
+//   EG φ        ≡ νX. φ ∧ ◇X
+//   AG φ        ≡ νX. φ ∧ □X
+//   E[φ U ψ]    ≡ μX. ψ ∨ (φ ∧ ◇X)
+//   A[φ U ψ]    ≡ μX. ψ ∨ (φ ∧ □X ∧ ◇true)
+//                  (la cláusula `◇true` excluye deadlocks que no han
+//                   alcanzado ψ — coincide con la semántica AU clásica
+//                   donde un camino debe existir hasta ψ).
+//
+// Para evitar capturas accidentales en fórmulas anidadas (`EF (EF p)`),
+// generamos nombres de variable frescos en cada `gensym()`.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ctlToMu = ctlToMu;
+function makeGensym() {
+    let n = 0;
+    return () => `__X${n++}`;
+}
+/** Constantes ⊤/⊥ codificadas como `μX.X ∨ ¬X` evitables: usamos
+ *  atoms internos siempre verdaderos/falsos vía `or`/`and` vacíos? El
+ *  AST de μ no admite n-arios vacíos, así que codificamos con un
+ *  binder trivial:  ⊤ ≡ νX. X ;  ⊥ ≡ μX. X. */
+function muTrue(gensym) {
+    const x = gensym();
+    return { kind: 'nu', bind: x, body: { kind: 'var', name: x } };
+}
+function muFalse(gensym) {
+    const x = gensym();
+    return { kind: 'mu', bind: x, body: { kind: 'var', name: x } };
+}
+function bigAnd(parts, gensym) {
+    if (parts.length === 0)
+        return muTrue(gensym);
+    let acc = parts[0];
+    for (let i = 1; i < parts.length; i++) {
+        acc = { kind: 'and', left: acc, right: parts[i] };
+    }
+    return acc;
+}
+function bigOr(parts, gensym) {
+    if (parts.length === 0)
+        return muFalse(gensym);
+    let acc = parts[0];
+    for (let i = 1; i < parts.length; i++) {
+        acc = { kind: 'or', left: acc, right: parts[i] };
+    }
+    return acc;
+}
+function translate(phi, gensym) {
+    switch (phi.kind) {
+        case 'atom':
+            return { kind: 'atom', name: phi.name };
+        case 'true':
+            return muTrue(gensym);
+        case 'false':
+            return muFalse(gensym);
+        case 'not':
+            return { kind: 'not', arg: translate(phi.arg, gensym) };
+        case 'and':
+            return bigAnd(phi.args.map((a) => translate(a, gensym)), gensym);
+        case 'or':
+            return bigOr(phi.args.map((a) => translate(a, gensym)), gensym);
+        case 'implies': {
+            // p → q ≡ ¬p ∨ q
+            return {
+                kind: 'or',
+                left: { kind: 'not', arg: translate(phi.left, gensym) },
+                right: translate(phi.right, gensym),
+            };
+        }
+        case 'EX':
+            return { kind: 'diamond', arg: translate(phi.arg, gensym) };
+        case 'AX':
+            return { kind: 'box', arg: translate(phi.arg, gensym) };
+        case 'EF': {
+            const x = gensym();
+            return {
+                kind: 'mu',
+                bind: x,
+                body: {
+                    kind: 'or',
+                    left: translate(phi.arg, gensym),
+                    right: { kind: 'diamond', arg: { kind: 'var', name: x } },
+                },
+            };
+        }
+        case 'AF': {
+            const x = gensym();
+            return {
+                kind: 'mu',
+                bind: x,
+                body: {
+                    kind: 'or',
+                    left: translate(phi.arg, gensym),
+                    right: { kind: 'box', arg: { kind: 'var', name: x } },
+                },
+            };
+        }
+        case 'EG': {
+            const x = gensym();
+            return {
+                kind: 'nu',
+                bind: x,
+                body: {
+                    kind: 'and',
+                    left: translate(phi.arg, gensym),
+                    right: { kind: 'diamond', arg: { kind: 'var', name: x } },
+                },
+            };
+        }
+        case 'AG': {
+            const x = gensym();
+            return {
+                kind: 'nu',
+                bind: x,
+                body: {
+                    kind: 'and',
+                    left: translate(phi.arg, gensym),
+                    right: { kind: 'box', arg: { kind: 'var', name: x } },
+                },
+            };
+        }
+        case 'EU': {
+            // E[A U B] ≡ μX. B ∨ (A ∧ ◇X)
+            const x = gensym();
+            return {
+                kind: 'mu',
+                bind: x,
+                body: {
+                    kind: 'or',
+                    left: translate(phi.right, gensym),
+                    right: {
+                        kind: 'and',
+                        left: translate(phi.left, gensym),
+                        right: { kind: 'diamond', arg: { kind: 'var', name: x } },
+                    },
+                },
+            };
+        }
+        case 'AU': {
+            // A[A U B] ≡ μX. B ∨ (A ∧ □X ∧ ◇⊤)
+            const x = gensym();
+            return {
+                kind: 'mu',
+                bind: x,
+                body: {
+                    kind: 'or',
+                    left: translate(phi.right, gensym),
+                    right: {
+                        kind: 'and',
+                        left: translate(phi.left, gensym),
+                        right: {
+                            kind: 'and',
+                            left: { kind: 'box', arg: { kind: 'var', name: x } },
+                            right: { kind: 'diamond', arg: muTrue(gensym) },
+                        },
+                    },
+                },
+            };
+        }
+    }
+}
+/**
+ * Traduce una fórmula CTL a su equivalente en μ-cálculo.
+ *
+ * Acepta el shape estructural del AST de CTL (sin importar la fuente
+ * exacta) — útil para evitar acoplamiento directo con `src/profiles/ctl`.
+ */
+function ctlToMu(ctlFormula) {
+    return translate(ctlFormula, makeGensym());
+}
+//# sourceMappingURL=ctl-translate.js.map

package/dist/profiles/mu-calculus/ctl-translate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ctl-translate.js","sourceRoot":"","sources":["../../../src/profiles/mu-calculus/ctl-translate.ts"],"names":[],"mappings":"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"}

package/dist/profiles/mu-calculus/index.d.ts

@@ -0,0 +1,7 @@
+export type { MuFormula, MuVarName, KripkeStructure } from './types';
+export { muToString } from './types';
+export { modelCheck, satisfiesAt } from './check';
+export { isWellFormed, isClosed, isPositive, freeVars, alternationDepth } from './wellformed';
+export { ctlToMu } from './ctl-translate';
+export type { CTLLike } from './ctl-translate';
+//# sourceMappingURL=index.d.ts.map

package/dist/profiles/mu-calculus/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/profiles/mu-calculus/index.ts"],"names":[],"mappings":"AAiBA,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AACrE,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAC9F,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,YAAY,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/profiles/mu-calculus/index.js

@@ -0,0 +1,33 @@
+"use strict";
+// ============================================================
+// ST modal μ-calculus — punto de entrada público
+// ============================================================
+// API:
+//   modelCheck(K, φ)        → Set<stateId> que satisfacen φ
+//   satisfiesAt(K, φ, s)    → boolean
+//   isWellFormed(φ)         → boolean (cerrada + positiva)
+//   isClosed(φ) / freeVars(φ) → análisis sintáctico
+//   alternationDepth(φ)     → number
+//   ctlToMu(ctlFormula)     → MuFormula
+//   muToString(φ)           → notación textual
+//
+// El μ-cálculo subsume CTL, LTL y PDL: cualquier fórmula CTL puede
+// traducirse vía `ctlToMu`. Es el "ensemble logic" de la familia
+// modal/temporal.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ctlToMu = exports.alternationDepth = exports.freeVars = exports.isPositive = exports.isClosed = exports.isWellFormed = exports.satisfiesAt = exports.modelCheck = exports.muToString = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "muToString", { enumerable: true, get: function () { return types_1.muToString; } });
+var check_1 = require("./check");
+Object.defineProperty(exports, "modelCheck", { enumerable: true, get: function () { return check_1.modelCheck; } });
+Object.defineProperty(exports, "satisfiesAt", { enumerable: true, get: function () { return check_1.satisfiesAt; } });
+var wellformed_1 = require("./wellformed");
+Object.defineProperty(exports, "isWellFormed", { enumerable: true, get: function () { return wellformed_1.isWellFormed; } });
+Object.defineProperty(exports, "isClosed", { enumerable: true, get: function () { return wellformed_1.isClosed; } });
+Object.defineProperty(exports, "isPositive", { enumerable: true, get: function () { return wellformed_1.isPositive; } });
+Object.defineProperty(exports, "freeVars", { enumerable: true, get: function () { return wellformed_1.freeVars; } });
+Object.defineProperty(exports, "alternationDepth", { enumerable: true, get: function () { return wellformed_1.alternationDepth; } });
+var ctl_translate_1 = require("./ctl-translate");
+Object.defineProperty(exports, "ctlToMu", { enumerable: true, get: function () { return ctl_translate_1.ctlToMu; } });
+//# sourceMappingURL=index.js.map

package/dist/profiles/mu-calculus/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/profiles/mu-calculus/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,iDAAiD;AACjD,+DAA+D;AAC/D,OAAO;AACP,4DAA4D;AAC5D,sCAAsC;AACtC,2DAA2D;AAC3D,oDAAoD;AACpD,qCAAqC;AACrC,wCAAwC;AACxC,+CAA+C;AAC/C,EAAE;AACF,mEAAmE;AACnE,iEAAiE;AACjE,kBAAkB;AAClB,+DAA+D;;;AAG/D,iCAAqC;AAA5B,mGAAA,UAAU,OAAA;AACnB,iCAAkD;AAAzC,mGAAA,UAAU,OAAA;AAAE,oGAAA,WAAW,OAAA;AAChC,2CAA8F;AAArF,0GAAA,YAAY,OAAA;AAAE,sGAAA,QAAQ,OAAA;AAAE,wGAAA,UAAU,OAAA;AAAE,sGAAA,QAAQ,OAAA;AAAE,8GAAA,gBAAgB,OAAA;AACvE,iDAA0C;AAAjC,wGAAA,OAAO,OAAA"}

package/dist/profiles/mu-calculus/types.d.ts

@@ -0,0 +1,51 @@
+/** Variable proposicional ligada por μ/ν. */
+export type MuVarName = string;
+/** AST del modal μ-calculus. */
+export type MuFormula = {
+    kind: 'atom';
+    name: string;
+} | {
+    kind: 'var';
+    name: MuVarName;
+} | {
+    kind: 'not';
+    arg: MuFormula;
+} | {
+    kind: 'and';
+    left: MuFormula;
+    right: MuFormula;
+} | {
+    kind: 'or';
+    left: MuFormula;
+    right: MuFormula;
+} | {
+    kind: 'box';
+    arg: MuFormula;
+} | {
+    kind: 'diamond';
+    arg: MuFormula;
+} | {
+    kind: 'mu';
+    bind: MuVarName;
+    body: MuFormula;
+} | {
+    kind: 'nu';
+    bind: MuVarName;
+    body: MuFormula;
+};
+/**
+ * Estructura de Kripke en el formato pedido por la API pública del
+ * perfil. `labelling[stateId]` es el conjunto de proposiciones que
+ * se cumplen en ese estado.
+ *
+ * El algoritmo asume estructuras finitas. Estados sin sucesores son
+ * "deadlocks": `□φ` se cumple trivialmente, `◇φ` es falso.
+ */
+export interface KripkeStructure {
+    states: string[];
+    transitions: Array<[string, string]>;
+    labelling: Record<string, Set<string>>;
+}
+/** Renderiza una fórmula μ-cálculo a notación textual estándar. */
+export declare function muToString(phi: MuFormula): string;
+//# sourceMappingURL=types.d.ts.map

package/dist/profiles/mu-calculus/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/profiles/mu-calculus/types.ts"],"names":[],"mappings":"AAgBA,6CAA6C;AAC7C,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC;AAE/B,gCAAgC;AAChC,MAAM,MAAM,SAAS,GACjB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,SAAS,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,GAAG,EAAE,SAAS,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAE,GAClD;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAE,GACjD;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,GAAG,EAAE,SAAS,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,GAAG,EAAE,SAAS,CAAA;CAAE,GACnC;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,SAAS,CAAA;CAAE,GAChD;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,SAAS,CAAA;CAAE,CAAC;AAErD;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,WAAW,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACrC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;CACxC;AAED,mEAAmE;AACnE,wBAAgB,UAAU,CAAC,GAAG,EAAE,SAAS,GAAG,MAAM,CAqBjD"}

package/dist/profiles/mu-calculus/types.js

@@ -0,0 +1,42 @@
+"use strict";
+// ============================================================
+// ST μ-calculus — tipos
+// ============================================================
+// Modal μ-calculus: lógica modal extendida con operadores de
+// punto fijo `μ` (least fixed-point) y `ν` (greatest fixed-point).
+// Subsume CTL, LTL y PDL: cualquier fórmula CTL puede traducirse
+// a μ-cálculo (ver `ctl-translate.ts`).
+//
+// Sintaxis:
+//   φ ::= p | X | ¬φ | φ ∧ φ | φ ∨ φ | □φ | ◇φ | μX. φ | νX. φ
+//
+// Restricción semántica: las variables ligadas deben aparecer
+// bajo un número par de negaciones (positividad / monotonicidad)
+// para que los puntos fijos existan por el teorema de Knaster-Tarski.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.muToString = muToString;
+/** Renderiza una fórmula μ-cálculo a notación textual estándar. */
+function muToString(phi) {
+    switch (phi.kind) {
+        case 'atom':
+            return phi.name;
+        case 'var':
+            return phi.name;
+        case 'not':
+            return `¬${muToString(phi.arg)}`;
+        case 'and':
+            return `(${muToString(phi.left)} ∧ ${muToString(phi.right)})`;
+        case 'or':
+            return `(${muToString(phi.left)} ∨ ${muToString(phi.right)})`;
+        case 'box':
+            return `□${muToString(phi.arg)}`;
+        case 'diamond':
+            return `◇${muToString(phi.arg)}`;
+        case 'mu':
+            return `μ${phi.bind}. ${muToString(phi.body)}`;
+        case 'nu':
+            return `ν${phi.bind}. ${muToString(phi.body)}`;
+    }
+}
+//# sourceMappingURL=types.js.map

package/dist/profiles/mu-calculus/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/profiles/mu-calculus/types.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,wBAAwB;AACxB,+DAA+D;AAC/D,6DAA6D;AAC7D,mEAAmE;AACnE,iEAAiE;AACjE,wCAAwC;AACxC,EAAE;AACF,YAAY;AACZ,+DAA+D;AAC/D,EAAE;AACF,8DAA8D;AAC9D,iEAAiE;AACjE,sEAAsE;AACtE,+DAA+D;;AAgC/D,gCAqBC;AAtBD,mEAAmE;AACnE,SAAgB,UAAU,CAAC,GAAc;IACvC,QAAQ,GAAG,CAAC,IAAI,EAAE,CAAC;QACjB,KAAK,MAAM;YACT,OAAO,GAAG,CAAC,IAAI,CAAC;QAClB,KAAK,KAAK;YACR,OAAO,GAAG,CAAC,IAAI,CAAC;QAClB,KAAK,KAAK;YACR,OAAO,IAAI,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;QACnC,KAAK,KAAK;YACR,OAAO,IAAI,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC;QAChE,KAAK,IAAI;YACP,OAAO,IAAI,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC;QAChE,KAAK,KAAK;YACR,OAAO,IAAI,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;QACnC,KAAK,SAAS;YACZ,OAAO,IAAI,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;QACnC,KAAK,IAAI;YACP,OAAO,IAAI,GAAG,CAAC,IAAI,KAAK,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QACjD,KAAK,IAAI;YACP,OAAO,IAAI,GAAG,CAAC,IAAI,KAAK,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;IACnD,CAAC;AACH,CAAC"}

package/dist/profiles/mu-calculus/wellformed.d.ts

@@ -0,0 +1,40 @@
+import type { MuFormula } from './types';
+/**
+ * Verifica que una fórmula sea sintácticamente bien formada:
+ *  - Cerrada (sin variables libres).
+ *  - Positiva en cada variable ligada (paridad par de negaciones).
+ *  - Sin shadowing nocivo: rebindings ocultan al outer, lo cual es
+ *    legal pero detectable. Aquí lo permitimos.
+ */
+export declare function isWellFormed(phi: MuFormula): boolean;
+/** Variables libres del término. */
+export declare function freeVars(phi: MuFormula): Set<string>;
+/** Una fórmula es cerrada cuando no tiene variables libres. */
+export declare function isClosed(phi: MuFormula): boolean;
+/**
+ * Una fórmula es positiva cuando toda `var X` ligada por un μ/ν
+ * aparece bajo un número par de negaciones desde su binder.
+ *
+ * Implementación: caminamos el AST con un map `binder → paridad`
+ * (0 = par, 1 = impar) que se actualiza al cruzar un `not`. Cuando
+ * vemos `var X`, miramos su binder más cercano y verificamos que
+ * su paridad relativa sea par.
+ */
+export declare function isPositive(phi: MuFormula): boolean;
+/**
+ * Profundidad de alternancia μ/ν. Métrica clásica:
+ *   ad(p) = ad(X) = 0
+ *   ad(¬φ) = ad(◇φ) = ad(□φ) = ad(φ)
+ *   ad(φ ∧ ψ) = ad(φ ∨ ψ) = max(ad(φ), ad(ψ))
+ *   ad(μX. φ) = max(1, ad(φ), 1 + maxNuAlt(φ))
+ *   ad(νX. φ) = max(1, ad(φ), 1 + maxMuAlt(φ))
+ * donde `maxNuAlt(φ)` es la profundidad considerando solo subfórmulas
+ * con binder ν cuyo cuerpo menciona la variable ligada externamente,
+ * y simétrico para μ.
+ *
+ * Aquí usamos la versión simplificada y muy usada en práctica
+ * (Cleaveland/Steffen): contar el cambio de tipo de binder en el
+ * camino sintáctico raíz→hoja.
+ */
+export declare function alternationDepth(phi: MuFormula): number;
+//# sourceMappingURL=wellformed.d.ts.map

package/dist/profiles/mu-calculus/wellformed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wellformed.d.ts","sourceRoot":"","sources":["../../../src/profiles/mu-calculus/wellformed.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,SAAS,GAAG,OAAO,CAEpD;AAED,oCAAoC;AACpC,wBAAgB,QAAQ,CAAC,GAAG,EAAE,SAAS,GAAG,GAAG,CAAC,MAAM,CAAC,CAIpD;AA+BD,+DAA+D;AAC/D,wBAAgB,QAAQ,CAAC,GAAG,EAAE,SAAS,GAAG,OAAO,CAEhD;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,SAAS,GAAG,OAAO,CAElD;AAmCD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,SAAS,GAAG,MAAM,CAEvD"}

package/dist/profiles/mu-calculus/wellformed.js

@@ -0,0 +1,160 @@
+"use strict";
+// ============================================================
+// μ-calculus — well-formedness y alternation depth
+// ============================================================
+// Una fórmula μ-cálculo es bien formada cuando:
+//   1. Es "cerrada": cada `var` ligada referencia un `μ`/`ν` que la
+//      envuelve sintácticamente.
+//   2. Es "positiva": cada variable ligada aparece bajo un número PAR
+//      de negaciones desde su binder. Esto garantiza monotonía del
+//      funcional asociado y la existencia de los puntos fijos por
+//      Knaster-Tarski.
+//
+// Alternation depth: máxima profundidad de anidamiento alternante
+// μ/ν con variables libres del binder externo. Aproximación estándar
+// (Niwiński/Emerson-Lei): si el body de un μX contiene νY donde Y
+// depende sintácticamente de X (o viceversa), la profundidad sube.
+// Aquí usamos la versión sintáctica simple: cuento bindings μ/ν
+// distintos en el camino raíz→hoja, contando saltos μ↔ν.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWellFormed = isWellFormed;
+exports.freeVars = freeVars;
+exports.isClosed = isClosed;
+exports.isPositive = isPositive;
+exports.alternationDepth = alternationDepth;
+/**
+ * Verifica que una fórmula sea sintácticamente bien formada:
+ *  - Cerrada (sin variables libres).
+ *  - Positiva en cada variable ligada (paridad par de negaciones).
+ *  - Sin shadowing nocivo: rebindings ocultan al outer, lo cual es
+ *    legal pero detectable. Aquí lo permitimos.
+ */
+function isWellFormed(phi) {
+    return isClosed(phi) && isPositive(phi);
+}
+/** Variables libres del término. */
+function freeVars(phi) {
+    const out = new Set();
+    collectFree(phi, new Set(), out);
+    return out;
+}
+function collectFree(phi, bound, out) {
+    switch (phi.kind) {
+        case 'atom':
+            return;
+        case 'var':
+            if (!bound.has(phi.name))
+                out.add(phi.name);
+            return;
+        case 'not':
+            collectFree(phi.arg, bound, out);
+            return;
+        case 'and':
+        case 'or':
+            collectFree(phi.left, bound, out);
+            collectFree(phi.right, bound, out);
+            return;
+        case 'box':
+        case 'diamond':
+            collectFree(phi.arg, bound, out);
+            return;
+        case 'mu':
+        case 'nu': {
+            const nextBound = new Set(bound);
+            nextBound.add(phi.bind);
+            collectFree(phi.body, nextBound, out);
+            return;
+        }
+    }
+}
+/** Una fórmula es cerrada cuando no tiene variables libres. */
+function isClosed(phi) {
+    return freeVars(phi).size === 0;
+}
+/**
+ * Una fórmula es positiva cuando toda `var X` ligada por un μ/ν
+ * aparece bajo un número par de negaciones desde su binder.
+ *
+ * Implementación: caminamos el AST con un map `binder → paridad`
+ * (0 = par, 1 = impar) que se actualiza al cruzar un `not`. Cuando
+ * vemos `var X`, miramos su binder más cercano y verificamos que
+ * su paridad relativa sea par.
+ */
+function isPositive(phi) {
+    return checkPositive(phi, new Map(), 0);
+}
+function checkPositive(phi, parityAt, parityHere) {
+    switch (phi.kind) {
+        case 'atom':
+            return true;
+        case 'var': {
+            const parityAtBinder = parityAt.get(phi.name);
+            if (parityAtBinder === undefined) {
+                // Variable libre: no es responsabilidad de positividad detectarlo.
+                return true;
+            }
+            // Paridad relativa = (parityHere - parityAtBinder) mod 2.
+            return (parityHere - parityAtBinder) % 2 === 0;
+        }
+        case 'not':
+            return checkPositive(phi.arg, parityAt, (parityHere + 1) % 2);
+        case 'and':
+        case 'or':
+            return (checkPositive(phi.left, parityAt, parityHere) &&
+                checkPositive(phi.right, parityAt, parityHere));
+        case 'box':
+        case 'diamond':
+            return checkPositive(phi.arg, parityAt, parityHere);
+        case 'mu':
+        case 'nu': {
+            const next = new Map(parityAt);
+            next.set(phi.bind, parityHere);
+            return checkPositive(phi.body, next, parityHere);
+        }
+    }
+}
+/**
+ * Profundidad de alternancia μ/ν. Métrica clásica:
+ *   ad(p) = ad(X) = 0
+ *   ad(¬φ) = ad(◇φ) = ad(□φ) = ad(φ)
+ *   ad(φ ∧ ψ) = ad(φ ∨ ψ) = max(ad(φ), ad(ψ))
+ *   ad(μX. φ) = max(1, ad(φ), 1 + maxNuAlt(φ))
+ *   ad(νX. φ) = max(1, ad(φ), 1 + maxMuAlt(φ))
+ * donde `maxNuAlt(φ)` es la profundidad considerando solo subfórmulas
+ * con binder ν cuyo cuerpo menciona la variable ligada externamente,
+ * y simétrico para μ.
+ *
+ * Aquí usamos la versión simplificada y muy usada en práctica
+ * (Cleaveland/Steffen): contar el cambio de tipo de binder en el
+ * camino sintáctico raíz→hoja.
+ */
+function alternationDepth(phi) {
+    return computeDepth(phi, null);
+}
+function computeDepth(phi, lastBinder) {
+    switch (phi.kind) {
+        case 'atom':
+        case 'var':
+            return 0;
+        case 'not':
+        case 'box':
+        case 'diamond':
+            return computeDepth(phi.arg, lastBinder);
+        case 'and':
+        case 'or':
+            return Math.max(computeDepth(phi.left, lastBinder), computeDepth(phi.right, lastBinder));
+        case 'mu': {
+            const inner = computeDepth(phi.body, 'mu');
+            // Mismo tipo de binder consecutivo: pertenece al mismo "segmento"
+            // y no aporta alternancia adicional. Cambio (o segmento inicial)
+            // suma 1 nivel al conteo del cuerpo.
+            return lastBinder === 'mu' ? inner : 1 + inner;
+        }
+        case 'nu': {
+            const inner = computeDepth(phi.body, 'nu');
+            return lastBinder === 'nu' ? inner : 1 + inner;
+        }
+    }
+}
+//# sourceMappingURL=wellformed.js.map

package/dist/profiles/mu-calculus/wellformed.js.map

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

package/dist/profiles/sequent-lk/cut-elimination.d.ts

@@ -0,0 +1,11 @@
+import { LKProof } from './types';
+/**
+ * Elimina todos los cortes de la derivacion. Devuelve una derivacion
+ * estructuralmente equivalente al mismo secuente sin nodos `cut`.
+ *
+ * Implementacion: eliminamos primero los cortes interiores (de las
+ * hojas hacia la raiz) y luego reducimos el cut de la raiz aplicando
+ * la regla principal correspondiente.
+ */
+export declare function eliminateCut(proof: LKProof): LKProof;
+//# sourceMappingURL=cut-elimination.d.ts.map

package/dist/profiles/sequent-lk/cut-elimination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cut-elimination.d.ts","sourceRoot":"","sources":["../../../src/profiles/sequent-lk/cut-elimination.ts"],"names":[],"mappings":"AA0BA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AA+JlC;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAsBpD"}