@stevenvo780/st-lang 4.5.2 → 4.6.0

package/dist/categorical/poset.js

@@ -0,0 +1,115 @@
+"use strict";
+// ============================================================
+// ST Categorical — Poset como categoría
+// ============================================================
+// Un poset (P, ≤) genera una categoría con un único morfismo a→b
+// por cada par (a, b) tal que a ≤ b. La identidad es a ≤ a y la
+// composición es transitividad. Reflexividad y transitividad están
+// validadas por construcción.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Poset = Poset;
+/**
+ * Construye la categoría poset. `elements` define los objetos y
+ * `leq` los pares a≤b explícitos. La clausura reflexivo-transitiva
+ * se calcula y se realiza como morfismos del Category resultante.
+ */
+function Poset(elements, leq) {
+    // Clausura reflexivo-transitiva sobre la relación dada.
+    const closure = new Set();
+    for (const e of elements)
+        closure.add(`${e}|${e}`);
+    for (const [a, b] of leq)
+        closure.add(`${a}|${b}`);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        const snapshot = Array.from(closure).map((s) => s.split('|'));
+        for (const [a, b] of snapshot) {
+            for (const [c, d] of snapshot) {
+                if (b === c) {
+                    const key = `${a}|${d}`;
+                    if (!closure.has(key)) {
+                        closure.add(key);
+                        changed = true;
+                    }
+                }
+            }
+        }
+    }
+    // Antisimetría se asume verificada por el cliente (no la chequeamos
+    // aquí — si el cliente da un ciclo, simplemente colapsa elementos en
+    // la categoría resultante y los tests lo detectarán).
+    const morphisms = new Map();
+    for (const key of closure) {
+        const [a, b] = key.split('|');
+        const mid = `${a}→${b}:leq`;
+        morphisms.set(mid, { id: mid, src: a, tgt: b });
+    }
+    const objectsSet = new Set(elements);
+    function identity(obj) {
+        const m = morphisms.get(`${obj}→${obj}:leq`);
+        if (!m)
+            throw new Error(`Poset: missing identity for ${obj}`);
+        return m;
+    }
+    function compose(g, f) {
+        if (f.tgt !== g.src) {
+            throw new Error(`Poset compose: dom mismatch ${f.id} ; ${g.id}`);
+        }
+        const id = `${f.src}→${g.tgt}:leq`;
+        const m = morphisms.get(id);
+        if (!m)
+            throw new Error(`Poset compose: missing morphism ${id}`);
+        return m;
+    }
+    function source(m) {
+        return m.src;
+    }
+    function target(m) {
+        return m.tgt;
+    }
+    function eqMor(a, b) {
+        return a.id === b.id;
+    }
+    function eqObj(a, b) {
+        return a === b;
+    }
+    function hom(a, b) {
+        const m = morphisms.get(`${a}→${b}:leq`);
+        return m ? [m] : [];
+    }
+    function verifyAssociativity() {
+        // En un poset cualquier composición es única, asociativa por
+        // construcción.
+        return true;
+    }
+    function verifyIdentity() {
+        // Reflexividad y composición con identidad: triviales por
+        // construcción al estar la clausura reflexiva añadida.
+        for (const m of morphisms.values()) {
+            const idSrc = identity(m.src);
+            const idTgt = identity(m.tgt);
+            if (compose(m, idSrc).id !== m.id)
+                return false;
+            if (compose(idTgt, m).id !== m.id)
+                return false;
+        }
+        return true;
+    }
+    return {
+        name: 'Poset',
+        objects: objectsSet,
+        morphisms,
+        identity,
+        compose,
+        source,
+        target,
+        eqMor,
+        eqObj,
+        hom,
+        verifyAssociativity,
+        verifyIdentity,
+    };
+}
+//# sourceMappingURL=poset.js.map

package/dist/categorical/poset.js.map

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

package/dist/categorical/types.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Identidad estable de un morfismo. Las categorías construidas
+ * en este módulo usan strings derivados de `src→tgt:name`, pero
+ * un cliente puede definir su propio esquema mientras sea único.
+ */
+export type MorId = string;
+/**
+ * Una categoría sobre objetos `Obj` y morfismos `Mor`. Las
+ * propiedades `objects` y `morphisms` exponen el grafo subyacente
+ * para tests y consumidores que necesiten iterar.
+ *
+ * Los morfismos viven en un `Map<MorId, Mor>` para que el chequeo
+ * de leyes pueda muestrear pares aleatorios sin coste prohibitivo.
+ */
+export interface Category<Obj, Mor> {
+    readonly name: string;
+    readonly objects: Set<Obj>;
+    readonly morphisms: Map<MorId, Mor>;
+    /** Devuelve la identidad para un objeto (axioma: existe y es única). */
+    identity(obj: Obj): Mor;
+    /** Composición g ∘ f (lee de derecha a izquierda: aplica f y luego g). */
+    compose(g: Mor, f: Mor): Mor;
+    /** Dominio del morfismo. */
+    source(m: Mor): Obj;
+    /** Codominio del morfismo. */
+    target(m: Mor): Obj;
+    /** Igualdad de morfismos (semántica del modelo concreto). */
+    eqMor(a: Mor, b: Mor): boolean;
+    /** Igualdad de objetos (semántica del modelo concreto). */
+    eqObj(a: Obj, b: Obj): boolean;
+    /** Devuelve todos los morfismos a→b. Útil para tests y para limits. */
+    hom(a: Obj, b: Obj): Mor[];
+    /** Verifica asociatividad: (h∘g)∘f = h∘(g∘f) sobre un muestreo. */
+    verifyAssociativity(sample?: number): boolean;
+    /** Verifica id ∘ f = f y f ∘ id = f. */
+    verifyIdentity(sample?: number): boolean;
+}
+/**
+ * Functor F : C → D, dado por su acción en objetos y morfismos.
+ * Debe preservar identidad y composición; ambas son verificables.
+ */
+export interface Functor<O1, M1, O2, M2> {
+    readonly name: string;
+    readonly source: Category<O1, M1>;
+    readonly target: Category<O2, M2>;
+    onObjects(obj: O1): O2;
+    onMorphisms(mor: M1): M2;
+    /** F(id_a) = id_{F(a)} para todo objeto. */
+    verifyIdentityPreservation(): boolean;
+    /** F(g∘f) = F(g)∘F(f). */
+    verifyComposition(sample?: number): boolean;
+}
+/**
+ * Transformación natural η : F ⇒ G entre functores paralelos
+ * F, G : C → D. Cada componente `η_a : F(a) → G(a)`. La condición
+ * de naturalidad es G(f) ∘ η_a = η_b ∘ F(f) para f : a→b en C.
+ */
+export interface NaturalTransformation<O1, M1, O2, M2> {
+    readonly name: string;
+    readonly source: Functor<O1, M1, O2, M2>;
+    readonly target: Functor<O1, M1, O2, M2>;
+    component(obj: O1): M2;
+    verifyNaturality(sample?: number): boolean;
+}
+/**
+ * Un diagrama es un functor desde una categoría índice J (típicamente
+ * pequeña, finita) a la categoría ambiente C. Para nuestros usos
+ * concretos representamos el diagrama por sus vértices (objetos
+ * de C imagen) y sus aristas (morfismos forzados entre ellos).
+ */
+export interface Diagram<O, M> {
+    readonly vertices: Map<string, O>;
+    readonly edges: Array<{
+        from: string;
+        to: string;
+        mor: M;
+    }>;
+}
+/**
+ * Cono sobre un diagrama: un objeto ápice junto con un morfismo
+ * (`leg`) hacia cada vértice del diagrama, conmutando con sus aristas.
+ */
+export interface Cone<O, M> {
+    apex: O;
+    legs: Map<string, M>;
+}
+/**
+ * Cocono (dual del cono): un ápice con morfismos *desde* cada vértice.
+ */
+export interface Cocone<O, M> {
+    apex: O;
+    legs: Map<string, M>;
+}
+/**
+ * Categoría monoidal: añade producto tensorial y unidad sobre
+ * la estructura categórica. No imponemos asociadores ni unitores
+ * explícitos — los modelos concretos (Set con ×) son estrictos
+ * suficiente para verificar α, λ, ρ por igualdad en objetos.
+ */
+export interface MonoidalCategory<O, M> extends Category<O, M> {
+    readonly unit: O;
+    tensor(a: O, b: O): O;
+    tensorMor(f: M, g: M): M;
+    /** Unitor izquierdo: 1 ⊗ a ≅ a (verificable por igualdad de objetos). */
+    verifyLeftUnitor(sample?: number): boolean;
+    /** Unitor derecho: a ⊗ 1 ≅ a. */
+    verifyRightUnitor(sample?: number): boolean;
+    /** Asociador: (a⊗b)⊗c = a⊗(b⊗c). */
+    verifyAssociator(sample?: number): boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/categorical/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/categorical/types.ts"],"names":[],"mappings":"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"}

package/dist/categorical/types.js

@@ -0,0 +1,15 @@
+"use strict";
+// ============================================================
+// ST Categorical — Tipos públicos
+// ============================================================
+// Definiciones de interfaz para Category, Functor,
+// NaturalTransformation, Cone, Diagram y MonoidalCategory.
+//
+// Decisión de diseño: cada morfismo se identifica por su `id`
+// (clave estable string-able). La categoría es responsable de
+// resolver compose / source / target a partir de la identidad
+// del morfismo. Esto permite igualdad estructural simple por
+// `id`, sin tener que comparar callbacks o funciones.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/categorical/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/categorical/types.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,kCAAkC;AAClC,+DAA+D;AAC/D,mDAAmD;AACnD,2DAA2D;AAC3D,EAAE;AACF,8DAA8D;AAC9D,8DAA8D;AAC9D,8DAA8D;AAC9D,6DAA6D;AAC7D,sDAAsD;AACtD,+DAA+D"}

package/dist/csp-hoare/analysis.d.ts

@@ -0,0 +1,51 @@
+import type { FailurePair, Process, Trace } from './types';
+/**
+ * Enumera todas las trazas de `p` hasta longitud `maxLength` (inclusive).
+ * Incluye la traza vacía (siempre presente) y los prefijos intermedios.
+ *
+ * Las trazas se devuelven sin duplicados, ordenadas por longitud
+ * ascendente, y como copias de arrays inmutables (las modificaciones no
+ * afectan el motor).
+ */
+export declare function traces(p: Process, maxLength?: number): Trace[];
+/**
+ * Calcula failures hasta `maxLength`. Para cada traza alcanzable, registra
+ * los refusal sets posibles iterando todas las resoluciones internas del
+ * estado tras la traza.
+ *
+ * Devuelve una lista (no un set) porque los refusal sets son objetos —
+ * agrupamos por igualdad estructural y deduplicamos manualmente.
+ */
+export declare function failures(p: Process, maxLength?: number): FailurePair[];
+/**
+ * Hay deadlock si el proceso no ofrece NINGÚN evento (ni siquiera ✓) en
+ * ALGUNA resolución interna alcanzable desde el estado inicial.
+ *
+ * En `STOP` el chequeo es trivial: `nextEvents(STOP) = ∅`.
+ */
+export declare function isDeadlocked(p: Process): boolean;
+/**
+ * Detección heurística de livelock: el proceso recorre eventos ocultos
+ * (τ) indefinidamente sin avanzar visiblemente. Implementación: chequea
+ * si la profundidad de despliegues internos excede `depth` sin ofrecer
+ * eventos visibles.
+ *
+ * No es decisión: usamos límite acotado. Útil para advertir sobre `μX.X`
+ * o `(a → STOP) \ {a}` con loop.
+ */
+export declare function isLiveLocked(p: Process, depth?: number): boolean;
+/**
+ * P ⊑_T Q : Q refina a P en trazas sii cada traza de Q es traza de P.
+ * Equivalentemente: Q no puede hacer nada que P no pudiera observar.
+ */
+export declare function refinesTraces(spec: Process, impl: Process, maxLength?: number): boolean;
+/**
+ * P ⊑_F Q : refinamiento en failures. Q refina a P sii:
+ *   (a) traces(Q) ⊆ traces(P)
+ *   (b) failures(Q) ⊆ failures(P)
+ *
+ * Una falla `(t, R)` de Q debe poder ser exhibida también por P. Esto
+ * capta el principio de que Q es "menos no-determinista" que P.
+ */
+export declare function refinesFailures(spec: Process, impl: Process, maxLength?: number): boolean;
+//# sourceMappingURL=analysis.d.ts.map

package/dist/csp-hoare/analysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analysis.d.ts","sourceRoot":"","sources":["../../src/csp-hoare/analysis.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAS,WAAW,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAKlE;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,SAAI,GAAG,KAAK,EAAE,CAqCzD;AAuBD;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,SAAI,GAAG,WAAW,EAAE,CAoCjE;AAwBD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAKhD;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,SAAK,GAAG,OAAO,CAS5D;AAqDD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,SAAI,GAAG,OAAO,CAOlF;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,SAAI,GAAG,OAAO,CA8BpF"}

package/dist/csp-hoare/analysis.js

@@ -0,0 +1,317 @@
+"use strict";
+// ============================================================
+// CSP Hoare — Trazas, failures, deadlock, livelock, refinement
+// ============================================================
+// Sobre la LTS definida en `semantics.ts` calculamos las semánticas
+// observacionales clásicas de CSP:
+//
+//   • traces(P)   — conjunto de prefijos de eventos visibles posibles.
+//   • failures(P) — pares (traza, refusal). El conjunto de refusal es el
+//                   conjunto de eventos que el proceso PUEDE rehusar tras
+//                   esa traza, bajo ALGUNA resolución del no-determinismo.
+//
+// Refinement (notación CSP estándar):
+//
+//   P ⊑_T Q   ⇔   traces(Q) ⊆ traces(P)
+//   P ⊑_F Q   ⇔   traces(Q) ⊆ traces(P) ∧ failures(Q) ⊆ failures(P)
+//
+// Intuición: Q refina a P sii Q es "más predecible" / "más determinista".
+// STOP es el refinement máximo: refina todo lo que tenga traza vacía.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traces = traces;
+exports.failures = failures;
+exports.isDeadlocked = isDeadlocked;
+exports.isLiveLocked = isLiveLocked;
+exports.refinesTraces = refinesTraces;
+exports.refinesFailures = refinesFailures;
+const semantics_1 = require("./semantics");
+// ── Trazas ──────────────────────────────────────────────────
+/**
+ * Enumera todas las trazas de `p` hasta longitud `maxLength` (inclusive).
+ * Incluye la traza vacía (siempre presente) y los prefijos intermedios.
+ *
+ * Las trazas se devuelven sin duplicados, ordenadas por longitud
+ * ascendente, y como copias de arrays inmutables (las modificaciones no
+ * afectan el motor).
+ */
+function traces(p, maxLength = 6) {
+    const seen = new Set();
+    const out = [];
+    const visit = (q, prefix) => {
+        const key = prefix.join('
');
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        out.push([...prefix]);
+        if (prefix.length >= maxLength)
+            return;
+        // Para enumerar trazas hay que considerar TODAS las resoluciones
+        // internas: cada rama puede ofrecer eventos distintos.
+        const resolutions = (0, semantics_1.internalResolutions)(q);
+        for (const r of resolutions) {
+            const initials = (0, semantics_1.nextEvents)(r);
+            for (const e of initials) {
+                const next = (0, semantics_1.step)(r, e);
+                if (next !== null) {
+                    visit(next, [...prefix, e]);
+                }
+            }
+        }
+    };
+    visit(p, []);
+    // Orden estable: por longitud, luego lex.
+    out.sort((a, b) => {
+        if (a.length !== b.length)
+            return a.length - b.length;
+        for (let i = 0; i < a.length; i++) {
+            const av = a[i] ?? '';
+            const bv = b[i] ?? '';
+            if (av !== bv)
+                return av < bv ? -1 : 1;
+        }
+        return 0;
+    });
+    return out;
+}
+// ── Failures ────────────────────────────────────────────────
+/**
+ * Para una RESOLUCIÓN interna estable `q`, el conjunto de refusal máximo
+ * sobre un alfabeto candidato `Σ` es: todo evento de `Σ` que `q` no
+ * ofrezca como inicial. (Definición estándar: R es refusal sii q no
+ * tiene transición para ningún a ∈ R.)
+ *
+ * `candidates` debe ser el conjunto de eventos relevantes (alfabeto de
+ * comparación) — típicamente la unión sintáctica de los alfabetos de los
+ * procesos involucrados en un test de refinement.
+ */
+function refusalsOf(q, candidates) {
+    const offered = (0, semantics_1.nextEvents)(q);
+    const r = new Set();
+    for (const e of candidates) {
+        if (!offered.has(e))
+            r.add(e);
+    }
+    return r;
+}
+/**
+ * Calcula failures hasta `maxLength`. Para cada traza alcanzable, registra
+ * los refusal sets posibles iterando todas las resoluciones internas del
+ * estado tras la traza.
+ *
+ * Devuelve una lista (no un set) porque los refusal sets son objetos —
+ * agrupamos por igualdad estructural y deduplicamos manualmente.
+ */
+function failures(p, maxLength = 4) {
+    const alphaPrime = collectVisibleEvents(p);
+    const reachable = [];
+    const seenStates = new Set();
+    const enqueue = (state, trace) => {
+        const key = trace.join('
');
+        if (seenStates.has(key))
+            return;
+        seenStates.add(key);
+        reachable.push({ state, trace });
+        if (trace.length >= maxLength)
+            return;
+        const resolutions = (0, semantics_1.internalResolutions)(state);
+        for (const r of resolutions) {
+            const initials = (0, semantics_1.nextEvents)(r);
+            for (const e of initials) {
+                const next = (0, semantics_1.step)(r, e);
+                if (next !== null)
+                    enqueue(next, [...trace, e]);
+            }
+        }
+    };
+    enqueue(p, []);
+    const out = [];
+    const seenPairs = new Set();
+    for (const { state, trace } of reachable) {
+        const resolutions = (0, semantics_1.internalResolutions)(state);
+        for (const r of resolutions) {
+            const ref = refusalsOf(r, alphaPrime);
+            const k = trace.join('
') + '|' + [...ref].sort().join(',');
+            if (seenPairs.has(k))
+                continue;
+            seenPairs.add(k);
+            out.push({ trace: [...trace], refusal: ref });
+        }
+    }
+    return out;
+}
+/** Alfabeto visible relevante (incluye tick si aparece). */
+function collectVisibleEvents(p) {
+    // Reaprovechamos `traces` superficialmente: alcanzamos hasta profundidad
+    // moderada para acumular eventos efectivamente observables.
+    const out = new Set();
+    const visit = (q, depth) => {
+        if (depth > 8)
+            return;
+        for (const r of (0, semantics_1.internalResolutions)(q)) {
+            const initials = (0, semantics_1.nextEvents)(r);
+            for (const e of initials) {
+                out.add(e);
+                const next = (0, semantics_1.step)(r, e);
+                if (next !== null)
+                    visit(next, depth + 1);
+            }
+        }
+    };
+    visit(p, 0);
+    return out;
+}
+// ── Deadlock / livelock ─────────────────────────────────────
+/**
+ * Hay deadlock si el proceso no ofrece NINGÚN evento (ni siquiera ✓) en
+ * ALGUNA resolución interna alcanzable desde el estado inicial.
+ *
+ * En `STOP` el chequeo es trivial: `nextEvents(STOP) = ∅`.
+ */
+function isDeadlocked(p) {
+    for (const r of (0, semantics_1.internalResolutions)(p)) {
+        if ((0, semantics_1.nextEvents)(r).size === 0)
+            return true;
+    }
+    return false;
+}
+/**
+ * Detección heurística de livelock: el proceso recorre eventos ocultos
+ * (τ) indefinidamente sin avanzar visiblemente. Implementación: chequea
+ * si la profundidad de despliegues internos excede `depth` sin ofrecer
+ * eventos visibles.
+ *
+ * No es decisión: usamos límite acotado. Útil para advertir sobre `μX.X`
+ * o `(a → STOP) \ {a}` con loop.
+ */
+function isLiveLocked(p, depth = 32) {
+    // Estrategia: si tras `depth` resoluciones internas seguidas no hay
+    // eventos visibles (cardinality 0) pero la recursión sigue siendo
+    // "productiva" internamente, lo consideramos livelock probable.
+    const initials = (0, semantics_1.nextEvents)(p);
+    if (initials.size > 0)
+        return false;
+    // Sin eventos: distinguir deadlock estructural (STOP) vs livelock real
+    // requiere examinar el cuerpo de la recursión.
+    return isLiveLockedRec(p, depth);
+}
+function isLiveLockedRec(p, depth) {
+    if (depth <= 0)
+        return true;
+    // Si hay recursión que se autoincorpora sin guarda visible, divergir.
+    if (p.kind === 'recursion') {
+        // Cuerpo sin prefix ni skip → diverge.
+        if (!hasVisibleGuard(p.body, p.name))
+            return true;
+        return false;
+    }
+    if (p.kind === 'hide') {
+        // Si todos los eventos iniciales son ocultos, podemos estar en un loop τ.
+        const hidden = new Set(p.events);
+        const inner = (0, semantics_1.nextEvents)(p.process);
+        if (inner.size === 0)
+            return false;
+        let allHidden = true;
+        for (const e of inner) {
+            if (!hidden.has(e)) {
+                allHidden = false;
+                break;
+            }
+        }
+        return allHidden;
+    }
+    return false;
+}
+function hasVisibleGuard(body, recName) {
+    switch (body.kind) {
+        case 'prefix':
+            return true; // hay un evento visible antes de recurrir.
+        case 'skip':
+            return true; // SKIP da ✓ (visible).
+        case 'choice':
+        case 'internal':
+        case 'parallel':
+        case 'interleave':
+        case 'sequence':
+            return hasVisibleGuard(body.left, recName) || hasVisibleGuard(body.right, recName);
+        case 'hide':
+        case 'rename':
+            return hasVisibleGuard(body.process, recName);
+        case 'recursion':
+            return hasVisibleGuard(body.body, recName);
+        case 'var':
+            return body.name !== recName; // si referencia otra var, asumimos guardada.
+        case 'stop':
+            return true; // STOP no es guarda pero tampoco divergente.
+    }
+}
+// ── Refinement ──────────────────────────────────────────────
+/**
+ * P ⊑_T Q : Q refina a P en trazas sii cada traza de Q es traza de P.
+ * Equivalentemente: Q no puede hacer nada que P no pudiera observar.
+ */
+function refinesTraces(spec, impl, maxLength = 6) {
+    const specTraces = encodeSet(traces(spec, maxLength));
+    const implTraces = traces(impl, maxLength);
+    for (const t of implTraces) {
+        if (!specTraces.has(encodeTrace(t)))
+            return false;
+    }
+    return true;
+}
+/**
+ * P ⊑_F Q : refinamiento en failures. Q refina a P sii:
+ *   (a) traces(Q) ⊆ traces(P)
+ *   (b) failures(Q) ⊆ failures(P)
+ *
+ * Una falla `(t, R)` de Q debe poder ser exhibida también por P. Esto
+ * capta el principio de que Q es "menos no-determinista" que P.
+ */
+function refinesFailures(spec, impl, maxLength = 4) {
+    if (!refinesTraces(spec, impl, maxLength))
+        return false;
+    const specF = failures(spec, maxLength);
+    const implF = failures(impl, maxLength);
+    // Para cada failure de impl, debe existir un failure de spec con la
+    // misma traza y un refusal ⊇ del de impl. (Refusal sets son cerrados
+    // por subconjunto en CSP: si P rehúsa R, también rehúsa todo R' ⊆ R.)
+    const specByTrace = new Map();
+    for (const f of specF) {
+        const k = encodeTrace(f.trace);
+        const arr = specByTrace.get(k) ?? [];
+        arr.push(f.refusal);
+        specByTrace.set(k, arr);
+    }
+    for (const f of implF) {
+        const k = encodeTrace(f.trace);
+        const candidates = specByTrace.get(k);
+        if (!candidates)
+            return false;
+        let matched = false;
+        for (const r of candidates) {
+            if (subsetEq(f.refusal, r)) {
+                matched = true;
+                break;
+            }
+        }
+        if (!matched)
+            return false;
+    }
+    return true;
+}
+function encodeTrace(t) {
+    return t.join('
');
+}
+function encodeSet(ts) {
+    const out = new Set();
+    for (const t of ts)
+        out.add(encodeTrace(t));
+    return out;
+}
+function subsetEq(a, b) {
+    for (const e of a)
+        if (!b.has(e))
+            return false;
+    return true;
+}
+//# sourceMappingURL=analysis.js.map

package/dist/csp-hoare/analysis.js.map

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