@stevenvo780/st-lang 4.13.0 → 4.14.0

package/dist/reasoning/model-checking/index.js

@@ -0,0 +1,786 @@
+"use strict";
+// ============================================================
+// ST Model Checking — Explicit-state model checker
+// ============================================================
+//
+// Verificación de propiedades sobre sistemas de transiciones
+// finitos (Kripke structures) mediante exploración explícita
+// del espacio de estados:
+//
+//   - Reachability: BFS desde estados iniciales con cota opcional.
+//   - Safety (G p / invariant p): DFS que falla en el primer
+//     estado donde p no se cumple y devuelve traza desde inicial.
+//   - Liveness (GF p, FG p): exploración con detección de ciclos
+//     accesibles (lasso = stem + loop) para encontrar contraejemplos
+//     o testigos.
+//   - Bounded model checking: BFS truncado a profundidad k.
+//   - Detección de deadlock: estado alcanzable sin sucesores.
+//
+// El espacio de estados es genérico: el usuario provee una
+// función `successors`, una función `hash` (clave canónica para
+// detección de visitados) y `labels` (proposiciones atómicas que
+// hold en el estado, opcional para uso futuro con LTL completo).
+//
+// Diseño:
+//   - Cada estado se canoniza por `hash(s)` (string). El usuario
+//     debe garantizar que estados equivalentes produzcan el mismo
+//     hash, y estados distintos hashes distintos.
+//   - Trazas y lassos se devuelven como arrays de S (no de hashes)
+//     para que el caller pueda inspeccionar los estados.
+//   - Las funciones nunca lanzan: cap `maxStates` para evitar
+//     explosión combinatoria sobre sistemas no acotados.
+//
+// Convención: las propiedades reciben un estado y devuelven boolean;
+// se asume que son puras y deterministas sobre el estado.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reachableStates = reachableStates;
+exports.checkSafety = checkSafety;
+exports.checkInvariant = checkInvariant;
+exports.bmc = bmc;
+exports.hasDeadlock = hasDeadlock;
+exports.checkAlwaysEventually = checkAlwaysEventually;
+exports.checkEventuallyAlways = checkEventuallyAlways;
+exports.mutualExclusionSpace = mutualExclusionSpace;
+exports.diningPhilosophersSpace = diningPhilosophersSpace;
+exports.readerWriterSpace = readerWriterSpace;
+const DEFAULT_MAX_STATES = 100_000;
+// ── Reachability (BFS) ───────────────────────────────────────
+/**
+ * Calcula el conjunto de estados alcanzables desde los estados
+ * iniciales del espacio. BFS por nivel; se detiene al agotar la
+ * frontera o al alcanzar `maxStates`.
+ */
+function reachableStates(space, opts = {}) {
+    const maxStates = opts.maxStates ?? DEFAULT_MAX_STATES;
+    const visited = new Map();
+    const queue = [];
+    for (const s of space.initial) {
+        const h = space.hash(s);
+        if (!visited.has(h)) {
+            visited.set(h, s);
+            queue.push(s);
+        }
+    }
+    let truncated = false;
+    while (queue.length > 0) {
+        if (visited.size >= maxStates) {
+            truncated = true;
+            break;
+        }
+        const cur = queue.shift();
+        for (const next of space.successors(cur)) {
+            const h = space.hash(next);
+            if (!visited.has(h)) {
+                visited.set(h, next);
+                queue.push(next);
+                if (visited.size >= maxStates) {
+                    truncated = true;
+                    break;
+                }
+            }
+        }
+        if (truncated)
+            break;
+    }
+    return {
+        states: Array.from(visited.values()),
+        explored: visited.size,
+        truncated,
+    };
+}
+// ── Reconstrucción de trazas ────────────────────────────────
+/**
+ * Reconstruye una traza desde un estado raíz (de `roots`) hasta
+ * el estado con hash `targetHash`, usando el mapa `parent` que
+ * mapea hash de hijo → { parent: S, hash: string } o null si root.
+ */
+function reconstructTrace(parent, byHash, targetHash) {
+    const path = [];
+    let h = targetHash;
+    const guard = new Set();
+    while (h !== null) {
+        if (guard.has(h))
+            break; // safety: no debería pasar
+        guard.add(h);
+        const node = byHash.get(h);
+        if (node === undefined)
+            break;
+        path.push(node);
+        const p = parent.get(h);
+        if (!p)
+            break;
+        h = p.parentHash;
+    }
+    return path.reverse();
+}
+// ── Safety (BFS con tracking de padre) ──────────────────────
+/**
+ * Verifica que `predicate` se cumple en *todos* los estados
+ * alcanzables. Si encuentra un estado violador, devuelve una
+ * traza mínima desde algún initial hasta él. Equivale a G p.
+ */
+function checkSafety(space, predicate, opts = {}) {
+    const maxStates = opts.maxStates ?? DEFAULT_MAX_STATES;
+    const visited = new Set();
+    const byHash = new Map();
+    const parent = new Map();
+    const queue = [];
+    for (const s of space.initial) {
+        const h = space.hash(s);
+        if (visited.has(h))
+            continue;
+        visited.add(h);
+        byHash.set(h, s);
+        parent.set(h, null);
+        if (!predicate(s)) {
+            return { safe: false, violatingState: s, trace: [s] };
+        }
+        queue.push(s);
+    }
+    while (queue.length > 0 && visited.size < maxStates) {
+        const cur = queue.shift();
+        const curHash = space.hash(cur);
+        for (const next of space.successors(cur)) {
+            const h = space.hash(next);
+            if (visited.has(h))
+                continue;
+            visited.add(h);
+            byHash.set(h, next);
+            parent.set(h, { parent: cur, parentHash: curHash });
+            if (!predicate(next)) {
+                return {
+                    safe: false,
+                    violatingState: next,
+                    trace: reconstructTrace(parent, byHash, h),
+                };
+            }
+            queue.push(next);
+        }
+    }
+    return { safe: true };
+}
+/** Alias semántico: invariante = safety check con el mismo predicado. */
+function checkInvariant(space, invariant, opts = {}) {
+    return checkSafety(space, invariant, opts);
+}
+// ── Bounded Model Checking ──────────────────────────────────
+/**
+ * BMC: busca un estado donde `predicate` falla dentro de los
+ * primeros `depth` pasos desde initial. No certifica safety
+ * global; sirve para encontrar contraejemplos cortos.
+ *
+ * `depth=0` solo evalúa estados iniciales.
+ */
+function bmc(space, predicate, depth) {
+    if (!Number.isFinite(depth) || depth < 0) {
+        return { safe: true };
+    }
+    const visited = new Set();
+    const byHash = new Map();
+    const parent = new Map();
+    // Cola con profundidad (BFS por nivel).
+    const queue = [];
+    for (const s of space.initial) {
+        const h = space.hash(s);
+        if (visited.has(h))
+            continue;
+        visited.add(h);
+        byHash.set(h, s);
+        parent.set(h, null);
+        if (!predicate(s)) {
+            return { safe: false, violatingState: s, trace: [s] };
+        }
+        queue.push({ s, d: 0 });
+    }
+    while (queue.length > 0) {
+        const item = queue.shift();
+        if (!item)
+            break;
+        const { s: cur, d } = item;
+        if (d >= depth)
+            continue;
+        const curHash = space.hash(cur);
+        for (const next of space.successors(cur)) {
+            const h = space.hash(next);
+            if (visited.has(h))
+                continue;
+            visited.add(h);
+            byHash.set(h, next);
+            parent.set(h, { parent: cur, parentHash: curHash });
+            if (!predicate(next)) {
+                return {
+                    safe: false,
+                    violatingState: next,
+                    trace: reconstructTrace(parent, byHash, h),
+                };
+            }
+            queue.push({ s: next, d: d + 1 });
+        }
+    }
+    return { safe: true };
+}
+// ── Deadlock ────────────────────────────────────────────────
+/**
+ * Detecta el primer estado alcanzable sin sucesores. Devuelve la
+ * traza desde initial hasta ese estado para diagnóstico.
+ */
+function hasDeadlock(space, opts = {}) {
+    const maxStates = opts.maxStates ?? DEFAULT_MAX_STATES;
+    const visited = new Set();
+    const byHash = new Map();
+    const parent = new Map();
+    const queue = [];
+    for (const s of space.initial) {
+        const h = space.hash(s);
+        if (visited.has(h))
+            continue;
+        visited.add(h);
+        byHash.set(h, s);
+        parent.set(h, null);
+        queue.push(s);
+    }
+    while (queue.length > 0 && visited.size < maxStates) {
+        const cur = queue.shift();
+        const curHash = space.hash(cur);
+        const succ = space.successors(cur);
+        if (succ.length === 0) {
+            return {
+                deadlocked: true,
+                state: cur,
+                trace: reconstructTrace(parent, byHash, curHash),
+            };
+        }
+        for (const next of succ) {
+            const h = space.hash(next);
+            if (visited.has(h))
+                continue;
+            visited.add(h);
+            byHash.set(h, next);
+            parent.set(h, { parent: cur, parentHash: curHash });
+            queue.push(next);
+        }
+    }
+    return { deadlocked: false };
+}
+// ── Búsqueda de lassos para liveness ────────────────────────
+/**
+ * Tarjan-like SCC sobre el sub-grafo de estados que cumplen
+ * `accepting`. Para GF p (always-eventually p): el sistema GF p
+ * holds sii toda SCC no-trivial accesible contiene al menos un
+ * estado donde p hold. Simplificación útil: bucle infinito
+ * factible sii hay un ciclo (≥1 arista) en la parte alcanzable
+ * cuyo support incluye un estado con p=true.
+ *
+ * Para FG p (eventually-always): hay ciclo enteramente dentro
+ * del subgrafo p=true accesible. Equivalente: una SCC no trivial
+ * contenida en el subgrafo restringido a estados p=true.
+ */
+function tarjanSCCs(space, nodes, edgeFilter) {
+    const indices = new Map();
+    const lowlink = new Map();
+    const onStack = new Set();
+    const stack = [];
+    const sccs = [];
+    let idx = 0;
+    const callStack = [];
+    for (const [startHash, startNode] of nodes) {
+        if (indices.has(startHash))
+            continue;
+        indices.set(startHash, idx);
+        lowlink.set(startHash, idx);
+        idx += 1;
+        stack.push(startHash);
+        onStack.add(startHash);
+        const startSucc = space
+            .successors(startNode)
+            .filter((n) => {
+            if (!edgeFilter(startNode, n))
+                return false;
+            return nodes.has(space.hash(n));
+        })
+            .map((n) => space.hash(n));
+        callStack.push({ hash: startHash, node: startNode, succHashes: startSucc, i: 0 });
+        while (callStack.length > 0) {
+            const frame = callStack[callStack.length - 1];
+            if (!frame)
+                break;
+            if (frame.i < frame.succHashes.length) {
+                const wHash = frame.succHashes[frame.i];
+                frame.i += 1;
+                if (!indices.has(wHash)) {
+                    const wNode = nodes.get(wHash);
+                    if (!wNode)
+                        continue;
+                    indices.set(wHash, idx);
+                    lowlink.set(wHash, idx);
+                    idx += 1;
+                    stack.push(wHash);
+                    onStack.add(wHash);
+                    const wSucc = space
+                        .successors(wNode)
+                        .filter((n) => {
+                        if (!edgeFilter(wNode, n))
+                            return false;
+                        return nodes.has(space.hash(n));
+                    })
+                        .map((n) => space.hash(n));
+                    callStack.push({ hash: wHash, node: wNode, succHashes: wSucc, i: 0 });
+                }
+                else if (onStack.has(wHash)) {
+                    const wIdx = indices.get(wHash);
+                    const cur = lowlink.get(frame.hash);
+                    if (wIdx < cur)
+                        lowlink.set(frame.hash, wIdx);
+                }
+            }
+            else {
+                // Pop the frame, propagate lowlink up.
+                const finishedHash = frame.hash;
+                callStack.pop();
+                const flow = lowlink.get(finishedHash);
+                const findex = indices.get(finishedHash);
+                if (flow === findex) {
+                    const scc = [];
+                    while (stack.length > 0) {
+                        const top = stack.pop();
+                        onStack.delete(top);
+                        scc.push(top);
+                        if (top === finishedHash)
+                            break;
+                    }
+                    sccs.push(scc);
+                }
+                const parentFrame = callStack[callStack.length - 1];
+                if (parentFrame) {
+                    const pl = lowlink.get(parentFrame.hash);
+                    if (flow < pl)
+                        lowlink.set(parentFrame.hash, flow);
+                }
+            }
+        }
+    }
+    return sccs;
+}
+/**
+ * Determina si una SCC es no-trivial: tiene >1 nodos o un único
+ * nodo con auto-bucle (self-loop) bajo `edgeFilter`.
+ */
+function sccNonTrivial(space, scc, nodes, edgeFilter) {
+    if (scc.length === 0)
+        return false;
+    if (scc.length > 1)
+        return true;
+    const onlyHash = scc[0];
+    const onlyNode = nodes.get(onlyHash);
+    if (!onlyNode)
+        return false;
+    for (const next of space.successors(onlyNode)) {
+        if (!edgeFilter(onlyNode, next))
+            continue;
+        if (space.hash(next) === onlyHash)
+            return true;
+    }
+    return false;
+}
+/**
+ * Encuentra un ciclo (loop) dentro de una SCC con ≥1 arista y
+ * lo devuelve como array de estados (cerrado: último → primero).
+ * Asume SCC no-trivial bajo `edgeFilter`.
+ */
+function findCycleInSCC(space, scc, nodes, edgeFilter) {
+    const sccSet = new Set(scc);
+    if (scc.length === 1) {
+        const onlyHash = scc[0];
+        const onlyNode = nodes.get(onlyHash);
+        if (!onlyNode)
+            return [];
+        return [onlyNode];
+    }
+    // BFS dentro de la SCC desde un nodo arbitrario hasta volver.
+    const startHash = scc[0];
+    const start = nodes.get(startHash);
+    if (!start)
+        return [];
+    // Buscamos el camino más corto start → start con ≥1 arista.
+    const parent = new Map();
+    const queue = [];
+    const succs = space
+        .successors(start)
+        .filter((n) => edgeFilter(start, n) && sccSet.has(space.hash(n)));
+    for (const n of succs) {
+        const h = space.hash(n);
+        if (!parent.has(h)) {
+            parent.set(h, { parentHash: startHash, node: start });
+            if (h === startHash) {
+                // self-loop (no debería entrar aquí porque scc.length>1, pero por defensa)
+                return [start];
+            }
+            queue.push({ hash: h, node: n });
+        }
+    }
+    while (queue.length > 0) {
+        const item = queue.shift();
+        if (!item)
+            break;
+        const { hash: curHash, node: cur } = item;
+        if (curHash === startHash)
+            break;
+        for (const next of space.successors(cur)) {
+            if (!edgeFilter(cur, next))
+                continue;
+            const nh = space.hash(next);
+            if (!sccSet.has(nh))
+                continue;
+            if (parent.has(nh))
+                continue;
+            parent.set(nh, { parentHash: curHash, node: cur });
+            if (nh === startHash) {
+                // reconstruir start → ... → cur → start
+                const path = [start];
+                const inverse = [];
+                let h = curHash;
+                while (h !== startHash) {
+                    const p = parent.get(h);
+                    if (!p)
+                        break;
+                    inverse.push(p.node);
+                    if (p.parentHash === startHash)
+                        break;
+                    h = p.parentHash;
+                }
+                // inverse va desde cur hacia atrás hasta el sucesor inmediato de start.
+                // path es [start, ...inverse.reverse(), cur]
+                // pero start ya está; añadimos camino inverso revertido (sin start), y luego cur.
+                // Cuidado: si solo hay 1 paso (start→cur→start), inverse = [start] (porque parent[cur] = start)
+                // path final esperado: [start, cur]
+                const inner = inverse.reverse();
+                // inner ahora incluye start como primer elemento si vino directo; lo limpiamos:
+                if (inner.length > 0 && space.hash(inner[0]) === startHash) {
+                    inner.shift();
+                }
+                for (const x of inner)
+                    path.push(x);
+                path.push(cur);
+                return path;
+            }
+            queue.push({ hash: nh, node: next });
+        }
+    }
+    // Fallback: ciclo trivial alrededor de start (no debería ocurrir si SCC es real).
+    return [start];
+}
+/**
+ * Camino más corto desde algún initial hasta `targetHash`,
+ * dentro del sub-grafo restringido por `nodes` y `edgeFilter`.
+ * Si no hay camino, devuelve [].
+ */
+function bfsStem(space, targetHash, nodes, edgeFilter) {
+    const parent = new Map();
+    const visited = new Set();
+    const byHash = new Map();
+    const queue = [];
+    for (const s of space.initial) {
+        const h = space.hash(s);
+        if (!nodes.has(h))
+            continue;
+        if (visited.has(h))
+            continue;
+        visited.add(h);
+        byHash.set(h, s);
+        if (h === targetHash) {
+            return [s];
+        }
+        queue.push(s);
+    }
+    while (queue.length > 0) {
+        const cur = queue.shift();
+        const curHash = space.hash(cur);
+        for (const next of space.successors(cur)) {
+            if (!edgeFilter(cur, next))
+                continue;
+            const nh = space.hash(next);
+            if (!nodes.has(nh))
+                continue;
+            if (visited.has(nh))
+                continue;
+            visited.add(nh);
+            byHash.set(nh, next);
+            parent.set(nh, { parentHash: curHash, node: cur });
+            if (nh === targetHash) {
+                // Reconstruir
+                const path = [next];
+                let h = curHash;
+                while (true) {
+                    const node = byHash.get(h);
+                    if (!node)
+                        break;
+                    path.push(node);
+                    const p = parent.get(h);
+                    if (!p)
+                        break;
+                    h = p.parentHash;
+                }
+                return path.reverse();
+            }
+            queue.push(next);
+        }
+    }
+    return [];
+}
+// ── Liveness: GF p (always eventually p) ────────────────────
+/**
+ * GF p: en todo camino infinito, p ocurre infinitas veces.
+ * Contraejemplo: lasso accesible (stem + loop) tal que NINGÚN
+ * estado del loop satisface p (porque entonces existe un camino
+ * infinito que evita p eventualmente).
+ *
+ * Algoritmo: SCCs no-triviales accesibles desde initial; si alguna
+ * NO contiene estado p=true → contraejemplo. Si todas las SCCs
+ * no-triviales accesibles contienen al menos un estado p=true,
+ * holds.
+ */
+function checkAlwaysEventually(space, p, opts = {}) {
+    const reach = reachableStates(space, opts);
+    const nodes = new Map();
+    for (const s of reach.states)
+        nodes.set(space.hash(s), s);
+    const allEdges = (_a, _b) => true;
+    const sccs = tarjanSCCs(space, nodes, allEdges);
+    for (const scc of sccs) {
+        if (!sccNonTrivial(space, scc, nodes, allEdges))
+            continue;
+        // ¿Hay algún estado en la SCC que satisfaga p?
+        let containsP = false;
+        for (const h of scc) {
+            const node = nodes.get(h);
+            if (node && p(node)) {
+                containsP = true;
+                break;
+            }
+        }
+        if (!containsP) {
+            // Construir contraejemplo lasso.
+            const loop = findCycleInSCC(space, scc, nodes, allEdges);
+            const target = loop[0];
+            if (!target)
+                continue;
+            const stem = bfsStem(space, space.hash(target), nodes, allEdges);
+            if (stem.length === 0)
+                continue;
+            return { holds: false, lasso: { stem, loop } };
+        }
+    }
+    return { holds: true };
+}
+// ── Liveness: FG p (eventually always p) ────────────────────
+/**
+ * FG p: existe un punto a partir del cual p siempre holds.
+ *
+ * Holds sii: existe un lasso accesible cuyo loop está contenido
+ * íntegramente en {s | p(s)}. Es decir, SCC no-trivial accesible
+ * dentro del sub-grafo inducido por p=true.
+ */
+function checkEventuallyAlways(space, p, opts = {}) {
+    const reach = reachableStates(space, opts);
+    // Sub-grafo de estados con p=true.
+    const pNodes = new Map();
+    for (const s of reach.states) {
+        if (p(s))
+            pNodes.set(space.hash(s), s);
+    }
+    // Aristas internas (from y to en pNodes).
+    const internalEdges = (from, to) => {
+        return pNodes.has(space.hash(from)) && pNodes.has(space.hash(to));
+    };
+    const sccs = tarjanSCCs(space, pNodes, internalEdges);
+    for (const scc of sccs) {
+        if (!sccNonTrivial(space, scc, pNodes, internalEdges))
+            continue;
+        const loop = findCycleInSCC(space, scc, pNodes, internalEdges);
+        const target = loop[0];
+        if (!target)
+            continue;
+        // El stem se construye en el grafo completo, no en el sub-grafo.
+        const allNodes = new Map();
+        for (const s of reach.states)
+            allNodes.set(space.hash(s), s);
+        const allEdges = (_a, _b) => true;
+        const stem = bfsStem(space, space.hash(target), allNodes, allEdges);
+        if (stem.length === 0)
+            continue;
+        return { holds: true, lasso: { stem, loop } };
+    }
+    return { holds: false };
+}
+function mutualExclusionSpace() {
+    const initial = [
+        { p1: 'idle', p2: 'idle', turn: 1 },
+        { p1: 'idle', p2: 'idle', turn: 2 },
+    ];
+    function step(proc, s) {
+        const my = proc === 1 ? s.p1 : s.p2;
+        const other = proc === 1 ? s.p2 : s.p1;
+        const otherProc = proc === 1 ? 2 : 1;
+        const out = [];
+        const set = (mine, turn) => {
+            if (proc === 1)
+                return { p1: mine, p2: s.p2, turn };
+            return { p1: s.p1, p2: mine, turn };
+        };
+        if (my === 'idle') {
+            // Peterson: al entrar en waiting, cedo turn al otro.
+            out.push(set('waiting', otherProc));
+        }
+        else if (my === 'waiting') {
+            // Entra a critical sii turn==self o other==idle.
+            if (s.turn === proc || other === 'idle') {
+                out.push(set('critical', s.turn));
+            }
+        }
+        else {
+            // critical → idle, conserva turn (el otro ya lo tendrá si tocó).
+            out.push(set('idle', s.turn));
+        }
+        return out;
+    }
+    return {
+        initial,
+        successors: (s) => [...step(1, s), ...step(2, s)],
+        labels: (s) => {
+            const ls = new Set();
+            if (s.p1 === 'critical')
+                ls.add('p1_critical');
+            if (s.p2 === 'critical')
+                ls.add('p2_critical');
+            if (s.p1 === 'critical' && s.p2 === 'critical')
+                ls.add('mutex_violation');
+            return ls;
+        },
+        equals: (a, b) => a.p1 === b.p1 && a.p2 === b.p2 && a.turn === b.turn,
+        hash: (s) => `${s.p1}|${s.p2}|${s.turn}`,
+    };
+}
+function diningPhilosophersSpace(n) {
+    if (n < 2)
+        throw new Error('n>=2 required');
+    const initialPhils = Array.from({ length: n }, () => 'thinking');
+    const initialForks = Array.from({ length: n }, () => false);
+    const initial = [{ phils: initialPhils, forks: initialForks }];
+    function leftFork(i) {
+        return i;
+    }
+    function rightFork(i) {
+        return (i + 1) % n;
+    }
+    function step(i, s) {
+        const phil = s.phils[i];
+        const out = [];
+        const cloneArr = (a) => a.slice();
+        if (phil === 'thinking') {
+            const lf = leftFork(i);
+            if (!s.forks[lf]) {
+                const newPhils = cloneArr(s.phils);
+                newPhils[i] = 'has_left';
+                const newForks = cloneArr(s.forks);
+                newForks[lf] = true;
+                out.push({ phils: newPhils, forks: newForks });
+            }
+        }
+        else if (phil === 'has_left') {
+            const rf = rightFork(i);
+            if (!s.forks[rf]) {
+                const newPhils = cloneArr(s.phils);
+                newPhils[i] = 'eating';
+                const newForks = cloneArr(s.forks);
+                newForks[rf] = true;
+                out.push({ phils: newPhils, forks: newForks });
+            }
+        }
+        else {
+            // eating → thinking, libera ambos.
+            const newPhils = cloneArr(s.phils);
+            newPhils[i] = 'thinking';
+            const newForks = cloneArr(s.forks);
+            newForks[leftFork(i)] = false;
+            newForks[rightFork(i)] = false;
+            out.push({ phils: newPhils, forks: newForks });
+        }
+        return out;
+    }
+    return {
+        initial,
+        successors: (s) => {
+            const out = [];
+            for (let i = 0; i < n; i += 1) {
+                for (const next of step(i, s))
+                    out.push(next);
+            }
+            return out;
+        },
+        labels: (s) => {
+            const ls = new Set();
+            for (let i = 0; i < n; i += 1) {
+                if (s.phils[i] === 'eating')
+                    ls.add(`eating_${i}`);
+            }
+            return ls;
+        },
+        equals: (a, b) => {
+            if (a.phils.length !== b.phils.length)
+                return false;
+            for (let i = 0; i < a.phils.length; i += 1) {
+                if (a.phils[i] !== b.phils[i])
+                    return false;
+            }
+            if (a.forks.length !== b.forks.length)
+                return false;
+            for (let i = 0; i < a.forks.length; i += 1) {
+                if (a.forks[i] !== b.forks[i])
+                    return false;
+            }
+            return true;
+        },
+        hash: (s) => `P:${s.phils.join(',')}|F:${s.forks.map((b) => (b ? '1' : '0')).join('')}`,
+    };
+}
+function readerWriterSpace(numReaders) {
+    if (numReaders < 1)
+        throw new Error('numReaders>=1 required');
+    const initial = [{ readers: 0, writer: false, maxReaders: numReaders }];
+    return {
+        initial,
+        successors: (s) => {
+            const out = [];
+            // Adquirir lectura.
+            if (!s.writer && s.readers < s.maxReaders) {
+                out.push({ readers: s.readers + 1, writer: false, maxReaders: s.maxReaders });
+            }
+            // Liberar lectura.
+            if (s.readers > 0) {
+                out.push({ readers: s.readers - 1, writer: false, maxReaders: s.maxReaders });
+            }
+            // Adquirir escritura.
+            if (s.readers === 0 && !s.writer) {
+                out.push({ readers: 0, writer: true, maxReaders: s.maxReaders });
+            }
+            // Liberar escritura.
+            if (s.writer) {
+                out.push({ readers: 0, writer: false, maxReaders: s.maxReaders });
+            }
+            return out;
+        },
+        labels: (s) => {
+            const ls = new Set();
+            if (s.writer)
+                ls.add('writer');
+            if (s.readers > 0)
+                ls.add('reading');
+            if (s.writer && s.readers > 0)
+                ls.add('rw_violation');
+            return ls;
+        },
+        equals: (a, b) => a.readers === b.readers && a.writer === b.writer && a.maxReaders === b.maxReaders,
+        hash: (s) => `R:${s.readers}|W:${s.writer ? '1' : '0'}|M:${s.maxReaders}`,
+    };
+}
+//# sourceMappingURL=index.js.map