@stevenvo780/st-lang 4.5.2 → 4.6.0

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

@@ -0,0 +1,33 @@
+import type { Process } from './types';
+/**
+ * Máquina expendedora simple: acepta una moneda y luego ofrece al
+ * entorno elegir entre té y café.
+ *
+ *   VM = coin → ((tea → STOP) □ (coffee → STOP))
+ *
+ * Para uso en bucle infinito, ver `vendingMachineLoop`.
+ */
+export declare function vendingMachine(): Process;
+/** Versión recursiva: tras servir, vuelve al estado inicial. */
+export declare function vendingMachineLoop(): Process;
+/**
+ * Filósofo `i` (dining philosophers a la Hoare): toma su tenedor
+ * izquierdo (`L`), luego el derecho (`R`), come, los suelta y repite.
+ *
+ *   PHIL_i = picks_up.L → picks_up.R → eats → puts_down.R → puts_down.L → STOP
+ *
+ * El bloqueo clásico aparece cuando todos los filósofos toman primero
+ * el izquierdo y luego intentan tomar el derecho: ya nadie lo tendrá
+ * libre. Lo detectamos con `isDeadlocked` sobre la composición paralela.
+ */
+export declare function philosopher(name: string): Process;
+/**
+ * Composición paralela de `n` filósofos circulares con sus tenedores
+ * compartidos. El alfabeto de sincronización es exactamente el conjunto
+ * de eventos `pick.*` y `put.*` que comparten filósofo y fork.
+ *
+ * Con `n ≥ 2` y la estrategia ingenua (todos toman primero el izquierdo)
+ * llegamos a deadlock estructural una vez todos hicieron `pick.L`.
+ */
+export declare function diningPhilosophers(n: number): Process;
+//# sourceMappingURL=examples.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"examples.d.ts","sourceRoot":"","sources":["../../src/csp-hoare/examples.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,OAAO,EAAS,MAAM,SAAS,CAAC;AAG9C;;;;;;;GAOG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAExC;AAED,gEAAgE;AAChE,wBAAgB,kBAAkB,IAAI,OAAO,CAK5C;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAOjD;AA0BD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CA+BrD"}

package/dist/csp-hoare/examples.js

@@ -0,0 +1,108 @@
+"use strict";
+// ============================================================
+// CSP Hoare — Ejemplos estándar del libro de Hoare (1985)
+// ============================================================
+// Construcciones canónicas que también sirven como tests integradores
+// de la semántica.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vendingMachine = vendingMachine;
+exports.vendingMachineLoop = vendingMachineLoop;
+exports.philosopher = philosopher;
+exports.diningPhilosophers = diningPhilosophers;
+const semantics_1 = require("./semantics");
+/**
+ * Máquina expendedora simple: acepta una moneda y luego ofrece al
+ * entorno elegir entre té y café.
+ *
+ *   VM = coin → ((tea → STOP) □ (coffee → STOP))
+ *
+ * Para uso en bucle infinito, ver `vendingMachineLoop`.
+ */
+function vendingMachine() {
+    return (0, semantics_1.prefix)('coin', (0, semantics_1.choice)((0, semantics_1.prefix)('tea', semantics_1.STOP), (0, semantics_1.prefix)('coffee', semantics_1.STOP)));
+}
+/** Versión recursiva: tras servir, vuelve al estado inicial. */
+function vendingMachineLoop() {
+    return (0, semantics_1.recursion)('VM', (0, semantics_1.prefix)('coin', (0, semantics_1.choice)((0, semantics_1.prefix)('tea', (0, semantics_1.processVar)('VM')), (0, semantics_1.prefix)('coffee', (0, semantics_1.processVar)('VM')))));
+}
+/**
+ * Filósofo `i` (dining philosophers a la Hoare): toma su tenedor
+ * izquierdo (`L`), luego el derecho (`R`), come, los suelta y repite.
+ *
+ *   PHIL_i = picks_up.L → picks_up.R → eats → puts_down.R → puts_down.L → STOP
+ *
+ * El bloqueo clásico aparece cuando todos los filósofos toman primero
+ * el izquierdo y luego intentan tomar el derecho: ya nadie lo tendrá
+ * libre. Lo detectamos con `isDeadlocked` sobre la composición paralela.
+ */
+function philosopher(name) {
+    const pickL = `pick.${name}.L`;
+    const pickR = `pick.${name}.R`;
+    const eats = `eat.${name}`;
+    const putR = `put.${name}.R`;
+    const putL = `put.${name}.L`;
+    return (0, semantics_1.prefix)(pickL, (0, semantics_1.prefix)(pickR, (0, semantics_1.prefix)(eats, (0, semantics_1.prefix)(putR, (0, semantics_1.prefix)(putL, semantics_1.STOP)))));
+}
+/**
+ * Tenedor `i`: oscila entre "libre" y "tomado". Solo puede ser tomado o
+ * soltado, alternativamente.
+ *
+ *   FORK_i = pick → put → FORK_i
+ *
+ * En el modelo de Hoare, los nombres de evento son compartidos entre
+ * filósofo y tenedor: `pick.phi.X` debe coincidir con el evento
+ * correspondiente del fork.
+ *
+ * Aquí codificamos el deadlock estructuralmente: la composición paralela
+ * de N filósofos sin recursión queda en STOP global cuando todos se
+ * bloquean.
+ */
+function fork(_forkId, philLeft, philRight) {
+    // El tenedor es L para `philLeft` y R para `philRight`.
+    const pickL = `pick.${philLeft}.L`;
+    const putL = `put.${philLeft}.L`;
+    const pickR = `pick.${philRight}.R`;
+    const putR = `put.${philRight}.R`;
+    // Solo aceptamos cada movimiento UNA vez (modelado finito → deadlock visible).
+    return (0, semantics_1.choice)((0, semantics_1.prefix)(pickL, (0, semantics_1.prefix)(putL, semantics_1.STOP)), (0, semantics_1.prefix)(pickR, (0, semantics_1.prefix)(putR, semantics_1.STOP)));
+}
+/**
+ * Composición paralela de `n` filósofos circulares con sus tenedores
+ * compartidos. El alfabeto de sincronización es exactamente el conjunto
+ * de eventos `pick.*` y `put.*` que comparten filósofo y fork.
+ *
+ * Con `n ≥ 2` y la estrategia ingenua (todos toman primero el izquierdo)
+ * llegamos a deadlock estructural una vez todos hicieron `pick.L`.
+ */
+function diningPhilosophers(n) {
+    if (n < 2)
+        throw new Error('diningPhilosophers requiere n ≥ 2');
+    // Construimos `n` filósofos y `n` tenedores en una mesa circular.
+    // Fork `i` está entre Phil `i` y Phil `(i+1) mod n`.
+    const phils = [];
+    const forks = [];
+    for (let i = 0; i < n; i++) {
+        phils.push(philosopher(`P${i}`));
+    }
+    for (let i = 0; i < n; i++) {
+        const left = `P${i}`;
+        const right = `P${(i + 1) % n}`;
+        forks.push(fork(i, left, right));
+    }
+    // Alfabeto: todos los `pick.*` y `put.*`.
+    const sync = [];
+    for (let i = 0; i < n; i++) {
+        sync.push(`pick.P${i}.L`, `pick.P${i}.R`, `put.P${i}.L`, `put.P${i}.R`);
+    }
+    // Componemos en cascada: ((Phil0 |[A]| Fork0) |[A]| Phil1) |[A]| ...
+    let acc = phils[0];
+    for (let i = 0; i < n; i++) {
+        acc = (0, semantics_1.parallel)(acc, forks[i], sync);
+        if (i + 1 < n) {
+            acc = (0, semantics_1.parallel)(acc, phils[i + 1], sync);
+        }
+    }
+    return acc;
+}
+//# sourceMappingURL=examples.js.map

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

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

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

@@ -0,0 +1,6 @@
+export type { Event, Process, Trace, FailurePair } from './types';
+export { TICK } from './types';
+export { STOP, SKIP, prefix, choice, internal, parallel, interleave, sequence, hide, rename, recursion, processVar, alphabet, nextEvents, step, internalResolutions, } from './semantics';
+export { traces, failures, isDeadlocked, isLiveLocked, refinesTraces, refinesFailures, } from './analysis';
+export { vendingMachine, vendingMachineLoop, philosopher, diningPhilosophers } from './examples';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/csp-hoare/index.ts"],"names":[],"mappings":"AAgBA,YAAY,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAClE,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAE/B,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,MAAM,EACN,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,IAAI,EACJ,MAAM,EACN,SAAS,EACT,UAAU,EACV,QAAQ,EACR,UAAU,EACV,IAAI,EACJ,mBAAmB,GACpB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,MAAM,EACN,QAAQ,EACR,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,eAAe,GAChB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC"}

package/dist/csp-hoare/index.js

@@ -0,0 +1,50 @@
+"use strict";
+// ============================================================
+// CSP Hoare — Comunicating Sequential Processes (Hoare 1978/1985)
+// ============================================================
+// Cálculo de procesos basado en eventos atómicos sincronizados.
+// A diferencia del π-cálculo (centrado en pasar nombres), CSP modela
+// concurrencia mediante la ocurrencia coordinada de nombres de evento
+// compartidos en el alfabeto del paralelo.
+//
+// Semánticas implementadas:
+//   • Traces — qué secuencias de eventos visibles pueden ocurrir.
+//   • Failures — pares (traza, refusal) que capturan no-determinismo.
+//   • Refinement — P ⊑_T Q y P ⊑_F Q según las semánticas anteriores.
+//
+// Ejemplos canónicos: máquina expendedora, filósofos cenando.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diningPhilosophers = exports.philosopher = exports.vendingMachineLoop = exports.vendingMachine = exports.refinesFailures = exports.refinesTraces = exports.isLiveLocked = exports.isDeadlocked = exports.failures = exports.traces = exports.internalResolutions = exports.step = exports.nextEvents = exports.alphabet = exports.processVar = exports.recursion = exports.rename = exports.hide = exports.sequence = exports.interleave = exports.parallel = exports.internal = exports.choice = exports.prefix = exports.SKIP = exports.STOP = exports.TICK = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "TICK", { enumerable: true, get: function () { return types_1.TICK; } });
+var semantics_1 = require("./semantics");
+Object.defineProperty(exports, "STOP", { enumerable: true, get: function () { return semantics_1.STOP; } });
+Object.defineProperty(exports, "SKIP", { enumerable: true, get: function () { return semantics_1.SKIP; } });
+Object.defineProperty(exports, "prefix", { enumerable: true, get: function () { return semantics_1.prefix; } });
+Object.defineProperty(exports, "choice", { enumerable: true, get: function () { return semantics_1.choice; } });
+Object.defineProperty(exports, "internal", { enumerable: true, get: function () { return semantics_1.internal; } });
+Object.defineProperty(exports, "parallel", { enumerable: true, get: function () { return semantics_1.parallel; } });
+Object.defineProperty(exports, "interleave", { enumerable: true, get: function () { return semantics_1.interleave; } });
+Object.defineProperty(exports, "sequence", { enumerable: true, get: function () { return semantics_1.sequence; } });
+Object.defineProperty(exports, "hide", { enumerable: true, get: function () { return semantics_1.hide; } });
+Object.defineProperty(exports, "rename", { enumerable: true, get: function () { return semantics_1.rename; } });
+Object.defineProperty(exports, "recursion", { enumerable: true, get: function () { return semantics_1.recursion; } });
+Object.defineProperty(exports, "processVar", { enumerable: true, get: function () { return semantics_1.processVar; } });
+Object.defineProperty(exports, "alphabet", { enumerable: true, get: function () { return semantics_1.alphabet; } });
+Object.defineProperty(exports, "nextEvents", { enumerable: true, get: function () { return semantics_1.nextEvents; } });
+Object.defineProperty(exports, "step", { enumerable: true, get: function () { return semantics_1.step; } });
+Object.defineProperty(exports, "internalResolutions", { enumerable: true, get: function () { return semantics_1.internalResolutions; } });
+var analysis_1 = require("./analysis");
+Object.defineProperty(exports, "traces", { enumerable: true, get: function () { return analysis_1.traces; } });
+Object.defineProperty(exports, "failures", { enumerable: true, get: function () { return analysis_1.failures; } });
+Object.defineProperty(exports, "isDeadlocked", { enumerable: true, get: function () { return analysis_1.isDeadlocked; } });
+Object.defineProperty(exports, "isLiveLocked", { enumerable: true, get: function () { return analysis_1.isLiveLocked; } });
+Object.defineProperty(exports, "refinesTraces", { enumerable: true, get: function () { return analysis_1.refinesTraces; } });
+Object.defineProperty(exports, "refinesFailures", { enumerable: true, get: function () { return analysis_1.refinesFailures; } });
+var examples_1 = require("./examples");
+Object.defineProperty(exports, "vendingMachine", { enumerable: true, get: function () { return examples_1.vendingMachine; } });
+Object.defineProperty(exports, "vendingMachineLoop", { enumerable: true, get: function () { return examples_1.vendingMachineLoop; } });
+Object.defineProperty(exports, "philosopher", { enumerable: true, get: function () { return examples_1.philosopher; } });
+Object.defineProperty(exports, "diningPhilosophers", { enumerable: true, get: function () { return examples_1.diningPhilosophers; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/csp-hoare/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,kEAAkE;AAClE,+DAA+D;AAC/D,gEAAgE;AAChE,qEAAqE;AACrE,sEAAsE;AACtE,2CAA2C;AAC3C,EAAE;AACF,4BAA4B;AAC5B,kEAAkE;AAClE,sEAAsE;AACtE,sEAAsE;AACtE,EAAE;AACF,8DAA8D;AAC9D,+DAA+D;;;AAG/D,iCAA+B;AAAtB,6FAAA,IAAI,OAAA;AAEb,yCAiBqB;AAhBnB,iGAAA,IAAI,OAAA;AACJ,iGAAA,IAAI,OAAA;AACJ,mGAAA,MAAM,OAAA;AACN,mGAAA,MAAM,OAAA;AACN,qGAAA,QAAQ,OAAA;AACR,qGAAA,QAAQ,OAAA;AACR,uGAAA,UAAU,OAAA;AACV,qGAAA,QAAQ,OAAA;AACR,iGAAA,IAAI,OAAA;AACJ,mGAAA,MAAM,OAAA;AACN,sGAAA,SAAS,OAAA;AACT,uGAAA,UAAU,OAAA;AACV,qGAAA,QAAQ,OAAA;AACR,uGAAA,UAAU,OAAA;AACV,iGAAA,IAAI,OAAA;AACJ,gHAAA,mBAAmB,OAAA;AAGrB,uCAOoB;AANlB,kGAAA,MAAM,OAAA;AACN,oGAAA,QAAQ,OAAA;AACR,wGAAA,YAAY,OAAA;AACZ,wGAAA,YAAY,OAAA;AACZ,yGAAA,aAAa,OAAA;AACb,2GAAA,eAAe,OAAA;AAGjB,uCAAiG;AAAxF,0GAAA,cAAc,OAAA;AAAE,8GAAA,kBAAkB,OAAA;AAAE,uGAAA,WAAW,OAAA;AAAE,8GAAA,kBAAkB,OAAA"}

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

@@ -0,0 +1,49 @@
+import type { Event, Process } from './types';
+export declare const STOP: Process;
+export declare const SKIP: Process;
+export declare function prefix(event: Event, cont: Process): Process;
+export declare function choice(left: Process, right: Process): Process;
+export declare function internal(left: Process, right: Process): Process;
+export declare function parallel(left: Process, right: Process, alphabet: Event[]): Process;
+export declare function interleave(left: Process, right: Process): Process;
+export declare function sequence(left: Process, right: Process): Process;
+export declare function hide(process: Process, events: Event[]): Process;
+export declare function rename(process: Process, mapping: Map<Event, Event>): Process;
+export declare function recursion(name: string, body: Process): Process;
+export declare function processVar(name: string): Process;
+/**
+ * Conjunto de eventos visibles mencionados sintácticamente en `p`.
+ * Los eventos renombrados aportan tanto la fuente como el destino
+ * (la fuente puede aparecer en una rama no recorrida, y el destino
+ * es lo que el entorno observa).
+ */
+export declare function alphabet(p: Process): Set<Event>;
+/**
+ * Eventos visibles que `p` puede ofrecer inmediatamente como su primer
+ * evento (tomando todas las resoluciones internas). No incluye τ (los
+ * eventos ocultos son silenciosos por construcción).
+ *
+ * Para `SKIP` reportamos el tick `✓` — termina exitosamente.
+ */
+export declare function nextEvents(p: Process): Set<Event>;
+/**
+ * `step(P, a)` aplica una transición visible etiquetada con `a` y devuelve
+ * el continuante, o `null` si `a` no está habilitado. Para procesos no-
+ * deterministas elegimos arbitrariamente cualquier rama que habilite `a`
+ * (eso es válido para análisis de trazas; para failures inspeccionamos
+ * todas las resoluciones aparte).
+ */
+export declare function step(p: Process, event: Event): Process | null;
+/**
+ * Enumera todos los estados "estables" alcanzables desde `p` resolviendo
+ * elecciones internas (`⊓`) y desplegando recursiones inmediatas, sin
+ * consumir eventos visibles. Útil para la semántica de failures, donde
+ * el conjunto de refusal depende de QUÉ rama interna se eligió.
+ *
+ * Devuelve procesos sin un `internal` en la raíz (después de empujarlo
+ * hacia adentro de operadores asociativos cuando aplica). El número de
+ * resoluciones es 2^(# de internals encadenados), así que limitamos a un
+ * número razonable para no explotar.
+ */
+export declare function internalResolutions(p: Process, limit?: number): Process[];
+//# sourceMappingURL=semantics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"semantics.d.ts","sourceRoot":"","sources":["../../src/csp-hoare/semantics.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAK9C,eAAO,MAAM,IAAI,EAAE,OAA0B,CAAC;AAC9C,eAAO,MAAM,IAAI,EAAE,OAA0B,CAAC;AAE9C,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAE3D;AACD,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAE7D;AACD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAE/D;AACD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,OAAO,CAElF;AACD,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAEjE;AACD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAE/D;AACD,wBAAgB,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,CAE/D;AACD,wBAAgB,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,OAAO,CAE5E;AACD,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAE9D;AACD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEhD;AAID;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,GAAG,GAAG,CAAC,KAAK,CAAC,CAI/C;AAiHD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,GAAG,GAAG,CAAC,KAAK,CAAC,CAIjD;AA8GD;;;;;;GAMG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,GAAG,IAAI,CAE7D;AA0HD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,SAAK,GAAG,OAAO,EAAE,CAIrE"}