@stevenvo780/st-lang 4.3.0 → 4.5.0

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

@@ -0,0 +1,172 @@
+"use strict";
+// ============================================================
+// μ-calculus model checker — algoritmo Emerson-Lei / Tarski
+// ============================================================
+// Semántica denotacional: ⟦φ⟧^ρ ⊆ S, donde ρ : Var → 2^S es el
+// "environment" que asigna conjuntos de estados a variables.
+//
+//   ⟦p⟧ρ        = { s ∈ S | p ∈ L(s) }
+//   ⟦X⟧ρ        = ρ(X)
+//   ⟦¬φ⟧ρ       = S \ ⟦φ⟧ρ
+//   ⟦φ ∧ ψ⟧ρ    = ⟦φ⟧ρ ∩ ⟦ψ⟧ρ
+//   ⟦φ ∨ ψ⟧ρ    = ⟦φ⟧ρ ∪ ⟦ψ⟧ρ
+//   ⟦□φ⟧ρ       = { s | ∀s'. s→s' ⇒ s' ∈ ⟦φ⟧ρ }
+//   ⟦◇φ⟧ρ       = { s | ∃s'. s→s' ∧ s' ∈ ⟦φ⟧ρ }
+//   ⟦μX. φ⟧ρ    = lfp T,  T(U) = ⟦φ⟧ρ[X↦U]
+//   ⟦νX. φ⟧ρ    = gfp T,  idem
+//
+// lfp/gfp se computan iterando desde ∅ / S hasta punto fijo
+// (Knaster-Tarski). Modelos finitos terminan en ≤ |S| iteraciones.
+// Complejidad O(|φ| · |S|^{ad(φ)+1}) en el peor caso.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelCheck = modelCheck;
+exports.satisfiesAt = satisfiesAt;
+function compile(K) {
+    const states = [...K.states];
+    const universe = new Set(states);
+    const labels = new Map();
+    const succ = new Map();
+    for (const s of states) {
+        labels.set(s, new Set(K.labelling[s] ?? []));
+        succ.set(s, new Set());
+    }
+    for (const [from, to] of K.transitions) {
+        if (!universe.has(from)) {
+            throw new Error(`μ-calculus: transición desde estado desconocido "${from}"`);
+        }
+        if (!universe.has(to)) {
+            throw new Error(`μ-calculus: transición hacia estado desconocido "${to}"`);
+        }
+        succ.get(from).add(to);
+    }
+    return { states, universe, labels, succ };
+}
+function evalFormula(model, phi, env) {
+    switch (phi.kind) {
+        case 'atom': {
+            const out = new Set();
+            for (const s of model.states) {
+                if (model.labels.get(s).has(phi.name))
+                    out.add(s);
+            }
+            return out;
+        }
+        case 'var': {
+            const v = env.get(phi.name);
+            if (!v) {
+                throw new Error(`μ-calculus: variable libre "${phi.name}" en evaluación`);
+            }
+            return new Set(v);
+        }
+        case 'not': {
+            const sub = evalFormula(model, phi.arg, env);
+            const out = new Set();
+            for (const s of model.states)
+                if (!sub.has(s))
+                    out.add(s);
+            return out;
+        }
+        case 'and': {
+            const l = evalFormula(model, phi.left, env);
+            const r = evalFormula(model, phi.right, env);
+            const out = new Set();
+            for (const s of l)
+                if (r.has(s))
+                    out.add(s);
+            return out;
+        }
+        case 'or': {
+            const l = evalFormula(model, phi.left, env);
+            const r = evalFormula(model, phi.right, env);
+            const out = new Set(l);
+            for (const s of r)
+                out.add(s);
+            return out;
+        }
+        case 'box': {
+            // □φ: todos los sucesores satisfacen φ (vacuamente true si no hay sucesores)
+            const sub = evalFormula(model, phi.arg, env);
+            const out = new Set();
+            for (const s of model.states) {
+                const succs = model.succ.get(s);
+                let allOk = true;
+                for (const t of succs) {
+                    if (!sub.has(t)) {
+                        allOk = false;
+                        break;
+                    }
+                }
+                if (allOk)
+                    out.add(s);
+            }
+            return out;
+        }
+        case 'diamond': {
+            // ◇φ: existe un sucesor que satisface φ
+            const sub = evalFormula(model, phi.arg, env);
+            const out = new Set();
+            for (const s of model.states) {
+                for (const t of model.succ.get(s)) {
+                    if (sub.has(t)) {
+                        out.add(s);
+                        break;
+                    }
+                }
+            }
+            return out;
+        }
+        case 'mu': {
+            // lfp: empezar desde ∅, iterar hasta punto fijo
+            let approx = new Set();
+            while (true) {
+                const next = evalFormula(model, phi.body, extend(env, phi.bind, approx));
+                if (setsEqual(approx, next))
+                    return approx;
+                approx = next;
+            }
+        }
+        case 'nu': {
+            // gfp: empezar desde S, iterar hasta punto fijo
+            let approx = new Set(model.states);
+            while (true) {
+                const next = evalFormula(model, phi.body, extend(env, phi.bind, approx));
+                if (setsEqual(approx, next))
+                    return approx;
+                approx = next;
+            }
+        }
+    }
+}
+function extend(env, name, value) {
+    const next = new Map(env);
+    next.set(name, value);
+    return next;
+}
+function setsEqual(a, b) {
+    if (a.size !== b.size)
+        return false;
+    for (const x of a)
+        if (!b.has(x))
+            return false;
+    return true;
+}
+/**
+ * Model checking de modal μ-calculus.
+ * Devuelve el conjunto de estados que satisfacen φ.
+ *
+ * Lanza si φ tiene variables libres no ligadas o si la fórmula no
+ * está bien formada en tiempo de ejecución (se recomienda chequear
+ * `isWellFormed(φ)` antes de invocar).
+ */
+function modelCheck(K, phi) {
+    const model = compile(K);
+    return evalFormula(model, phi, new Map());
+}
+/**
+ * `K, s ⊨ φ` para un estado puntual. Conveniencia sobre `modelCheck`.
+ */
+function satisfiesAt(K, phi, state) {
+    return modelCheck(K, phi).has(state);
+}
+//# sourceMappingURL=check.js.map

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

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

package/dist/profiles/mu-calculus/ctl-translate.d.ts

@@ -0,0 +1,61 @@
+import type { MuFormula } from './types';
+/** Subset de CTL que el translator entiende. Reproduce la forma del AST
+ *  de `src/profiles/ctl/types.ts` para que se pueda pasar tal cual. */
+export type CTLLike = {
+    kind: 'atom';
+    name: string;
+} | {
+    kind: 'true';
+} | {
+    kind: 'false';
+} | {
+    kind: 'not';
+    arg: CTLLike;
+} | {
+    kind: 'and';
+    args: CTLLike[];
+} | {
+    kind: 'or';
+    args: CTLLike[];
+} | {
+    kind: 'implies';
+    left: CTLLike;
+    right: CTLLike;
+} | {
+    kind: 'EX';
+    arg: CTLLike;
+} | {
+    kind: 'AX';
+    arg: CTLLike;
+} | {
+    kind: 'EF';
+    arg: CTLLike;
+} | {
+    kind: 'AF';
+    arg: CTLLike;
+} | {
+    kind: 'EG';
+    arg: CTLLike;
+} | {
+    kind: 'AG';
+    arg: CTLLike;
+} | {
+    kind: 'EU';
+    left: CTLLike;
+    right: CTLLike;
+} | {
+    kind: 'AU';
+    left: CTLLike;
+    right: CTLLike;
+};
+/**
+ * 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`.
+ */
+export declare function ctlToMu(ctlFormula: {
+    kind: string;
+    [k: string]: unknown;
+}): MuFormula;
+//# sourceMappingURL=ctl-translate.d.ts.map

package/dist/profiles/mu-calculus/ctl-translate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ctl-translate.d.ts","sourceRoot":"","sources":["../../../src/profiles/mu-calculus/ctl-translate.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC;uEACuE;AACvE,MAAM,MAAM,OAAO,GACf;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,GAAG,EAAE,OAAO,CAAA;CAAE,GAC7B;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,OAAO,EAAE,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,OAAO,EAAE,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAClD;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,GAAG,EAAE,OAAO,CAAA;CAAE,GAC5B;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,GAAG,EAAE,OAAO,CAAA;CAAE,GAC5B;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,GAAG,EAAE,OAAO,CAAA;CAAE,GAC5B;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,GAAG,EAAE,OAAO,CAAA;CAAE,GAC5B;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,GAAG,EAAE,OAAO,CAAA;CAAE,GAC5B;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,GAAG,EAAE,OAAO,CAAA;CAAE,GAC5B;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAgKlD;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,UAAU,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,GAAG,SAAS,CAErF"}

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"}