@stevenvo780/st-lang 4.9.0 → 4.10.0

package/dist/logic/profiles/natural-deduction-nk/types.js

@@ -0,0 +1,35 @@
+"use strict";
+// ============================================================
+// Natural Deduction NK (Gentzen classical) — Tipos
+// ============================================================
+//
+// Sistema NK de Gentzen para lógica proposicional clásica.
+// Extiende NJ (intuicionista) con reglas que justifican el
+// tercero excluido / doble negación clásica.
+//
+// Reglas intuicionistas heredadas (idéntico a NJ):
+//   - Conjunción:   ∧I, ∧EL, ∧ER
+//   - Disyunción:   ∨IL, ∨IR, ∨E (con descarga)
+//   - Implicación:  →I (descarga), →E (modus ponens)
+//   - Negación:     ¬I (descarga, deriva ⊥), ¬E (deriva ⊥)
+//   - Falsedad:     ⊥E (ex falso quodlibet)
+//   - Asunción:     hipótesis del contexto
+//
+// Reglas clásicas añadidas:
+//   - doubleNegE:   ¬¬φ ⊢ φ                 (eliminación doble negación)
+//   - LEM:          ⊢ φ ∨ ¬φ                (tercero excluido como axioma)
+//   - pierce:       ⊢ ((φ→ψ)→φ)→φ           (ley de Peirce como axioma)
+//   - rAA:          asume ¬φ, deriva ⊥, concluye φ (reductio ad absurdum)
+//
+// La regla rAA es la dual clásica de ¬I: en NJ, asumiendo φ y
+// derivando ⊥ se concluye ¬φ; en NK, asumiendo ¬φ y derivando
+// ⊥ se concluye φ. Con sólo rAA añadida a NJ se obtiene
+// completitud para la lógica clásica proposicional.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLASSICAL_ONLY_RULES = void 0;
+/**
+ * Conjunto de reglas que sólo existen en NK (no en NJ).
+ * Útil para detectar si una prueba NK es trasladable a NJ.
+ */
+exports.CLASSICAL_ONLY_RULES = ['doubleNegE', 'LEM', 'pierce', 'rAA'];
+//# sourceMappingURL=types.js.map

package/dist/logic/profiles/natural-deduction-nk/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/logic/profiles/natural-deduction-nk/types.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,mDAAmD;AACnD,+DAA+D;AAC/D,EAAE;AACF,2DAA2D;AAC3D,2DAA2D;AAC3D,6CAA6C;AAC7C,EAAE;AACF,mDAAmD;AACnD,iCAAiC;AACjC,gDAAgD;AAChD,qDAAqD;AACrD,2DAA2D;AAC3D,4CAA4C;AAC5C,2CAA2C;AAC3C,EAAE;AACF,4BAA4B;AAC5B,yEAAyE;AACzE,2EAA2E;AAC3E,wEAAwE;AACxE,0EAA0E;AAC1E,EAAE;AACF,8DAA8D;AAC9D,8DAA8D;AAC9D,wDAAwD;AACxD,oDAAoD;;;AAiDpD;;;GAGG;AACU,QAAA,oBAAoB,GAA0B,CAAC,YAAY,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC"}

package/dist/reasoning/automata/dfa.d.ts

@@ -0,0 +1,17 @@
+import type { DFA } from './types';
+/** ¿`M` acepta `input`? Si en algún punto no hay transición definida,
+ *  rechaza inmediatamente (DFA visto como función parcial). */
+export declare function dfaAccepts(M: DFA, input: string): boolean;
+/** Totaliza un DFA agregando un sink-state para las aristas faltantes.
+ *  Devuelve un DFA equivalente con `transitions` totales sobre alfabeto. */
+export declare function dfaTotalize(M: DFA, sinkName?: string): DFA;
+/** Complemento de `M`: misma estructura, accept = states \ accept. */
+export declare function dfaComplement(M: DFA): DFA;
+/** Producto cartesiano con predicado de aceptación arbitrario sobre
+ *  (a-state, b-state). Sólo se crean estados alcanzables desde el par
+ *  inicial. */
+export declare function dfaProduct(a: DFA, b: DFA, acceptPair: (sa: string, sb: string) => boolean): DFA;
+export declare function dfaUnion(a: DFA, b: DFA): DFA;
+export declare function dfaIntersection(a: DFA, b: DFA): DFA;
+export declare function dfaMinimize(M: DFA): DFA;
+//# sourceMappingURL=dfa.d.ts.map

package/dist/reasoning/automata/dfa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dfa.d.ts","sourceRoot":"","sources":["../../../src/reasoning/automata/dfa.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,GAAG,EAAU,MAAM,SAAS,CAAC;AAE3C;+DAC+D;AAC/D,wBAAgB,UAAU,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAUzD;AAED;4EAC4E;AAC5E,wBAAgB,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,QAAQ,SAAa,GAAG,GAAG,CAsC9D;AAED,sEAAsE;AACtE,wBAAgB,aAAa,CAAC,CAAC,EAAE,GAAG,GAAG,GAAG,CAWzC;AAED;;eAEe;AACf,wBAAgB,UAAU,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,UAAU,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,GAAG,GAAG,CAuC/F;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,GAAG,CAE5C;AAED,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,GAAG,CAEnD;AAaD,wBAAgB,WAAW,CAAC,CAAC,EAAE,GAAG,GAAG,GAAG,CAuHvC"}

package/dist/reasoning/automata/dfa.js

@@ -0,0 +1,276 @@
+"use strict";
+// ============================================================
+// ST Automata — DFA
+// ============================================================
+//
+// Operaciones sobre DFAs:
+//   · dfaAccepts        — simulación de aceptación.
+//   · dfaMinimize       — partición de equivalencia (Hopcroft).
+//   · dfaComplement     — invierte aceptación tras totalizar.
+//   · dfaProduct        — producto cartesiano con predicado de
+//                         aceptación (base de union/intersection).
+//   · dfaUnion          — L(a) ∪ L(b).
+//   · dfaIntersection   — L(a) ∩ L(b).
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dfaAccepts = dfaAccepts;
+exports.dfaTotalize = dfaTotalize;
+exports.dfaComplement = dfaComplement;
+exports.dfaProduct = dfaProduct;
+exports.dfaUnion = dfaUnion;
+exports.dfaIntersection = dfaIntersection;
+exports.dfaMinimize = dfaMinimize;
+/** ¿`M` acepta `input`? Si en algún punto no hay transición definida,
+ *  rechaza inmediatamente (DFA visto como función parcial). */
+function dfaAccepts(M, input) {
+    let current = M.initial;
+    for (const ch of input) {
+        if (current === undefined)
+            return false;
+        const row = M.transitions.get(current);
+        if (!row)
+            return false;
+        current = row.get(ch);
+        if (current === undefined)
+            return false;
+    }
+    return current !== undefined && M.accept.has(current);
+}
+/** Totaliza un DFA agregando un sink-state para las aristas faltantes.
+ *  Devuelve un DFA equivalente con `transitions` totales sobre alfabeto. */
+function dfaTotalize(M, sinkName = '__sink__') {
+    // Detectar si ya es total.
+    let needsSink = false;
+    for (const s of M.states) {
+        const row = M.transitions.get(s);
+        for (const a of M.alphabet) {
+            if (!row || !row.has(a)) {
+                needsSink = true;
+                break;
+            }
+        }
+        if (needsSink)
+            break;
+    }
+    if (!needsSink)
+        return M;
+    const states = new Set(M.states);
+    let sink = sinkName;
+    while (states.has(sink))
+        sink = sink + '_';
+    states.add(sink);
+    const transitions = new Map();
+    for (const s of states) {
+        const old = M.transitions.get(s);
+        const row = new Map();
+        for (const a of M.alphabet) {
+            const dst = old?.get(a);
+            row.set(a, dst ?? sink);
+        }
+        transitions.set(s, row);
+    }
+    return {
+        states,
+        alphabet: new Set(M.alphabet),
+        transitions,
+        initial: M.initial,
+        accept: new Set(M.accept),
+    };
+}
+/** Complemento de `M`: misma estructura, accept = states \ accept. */
+function dfaComplement(M) {
+    const total = dfaTotalize(M);
+    const accept = new Set();
+    for (const s of total.states)
+        if (!total.accept.has(s))
+            accept.add(s);
+    return {
+        states: total.states,
+        alphabet: total.alphabet,
+        transitions: total.transitions,
+        initial: total.initial,
+        accept,
+    };
+}
+/** Producto cartesiano con predicado de aceptación arbitrario sobre
+ *  (a-state, b-state). Sólo se crean estados alcanzables desde el par
+ *  inicial. */
+function dfaProduct(a, b, acceptPair) {
+    const ta = dfaTotalize(a);
+    const tb = dfaTotalize(b);
+    const alphabet = new Set([...ta.alphabet, ...tb.alphabet]);
+    const states = new Set();
+    const transitions = new Map();
+    const accept = new Set();
+    const encode = (sa, sb) => `(${sa}|${sb})`;
+    const initial = encode(ta.initial, tb.initial);
+    const queue = [[ta.initial, tb.initial]];
+    states.add(initial);
+    if (acceptPair(ta.initial, tb.initial))
+        accept.add(initial);
+    while (queue.length > 0) {
+        const pair = queue.shift();
+        if (!pair)
+            break;
+        const [sa, sb] = pair;
+        const key = encode(sa, sb);
+        const row = new Map();
+        transitions.set(key, row);
+        for (const sym of alphabet) {
+            const da = ta.transitions.get(sa)?.get(sym);
+            const db = tb.transitions.get(sb)?.get(sym);
+            if (da === undefined || db === undefined)
+                continue;
+            const nextKey = encode(da, db);
+            row.set(sym, nextKey);
+            if (!states.has(nextKey)) {
+                states.add(nextKey);
+                if (acceptPair(da, db))
+                    accept.add(nextKey);
+                queue.push([da, db]);
+            }
+        }
+    }
+    return { states, alphabet, transitions, initial, accept };
+}
+function dfaUnion(a, b) {
+    return dfaProduct(a, b, (sa, sb) => a.accept.has(sa) || b.accept.has(sb));
+}
+function dfaIntersection(a, b) {
+    return dfaProduct(a, b, (sa, sb) => a.accept.has(sa) && b.accept.has(sb));
+}
+// ── Minimización ─────────────────────────────────────────────
+//
+// Partition refinement à la Hopcroft (versión clásica simplificada):
+//
+//   1. Totalizar M.
+//   2. Eliminar estados inalcanzables desde el inicial.
+//   3. Partición inicial P = {Final, NonFinal}.
+//   4. Refinar: para cada (clase C, símbolo a), particionar cada otra
+//      clase Y según el predicado "δ(y,a) ∈ C".
+//   5. Cuando P no cambia, cada clase = estado del DFA mínimo.
+function dfaMinimize(M) {
+    const total = dfaTotalize(M);
+    // Reachable from initial.
+    const reachable = new Set([total.initial]);
+    const stack = [total.initial];
+    while (stack.length > 0) {
+        const s = stack.pop();
+        if (s === undefined)
+            break;
+        const row = total.transitions.get(s);
+        if (!row)
+            continue;
+        for (const dst of row.values()) {
+            if (!reachable.has(dst)) {
+                reachable.add(dst);
+                stack.push(dst);
+            }
+        }
+    }
+    const finals = new Set();
+    const nonFinals = new Set();
+    for (const s of reachable) {
+        if (total.accept.has(s))
+            finals.add(s);
+        else
+            nonFinals.add(s);
+    }
+    // Lista de bloques (clases). Cada estado tiene un blockId.
+    const blocks = [];
+    const blockOf = new Map();
+    const pushBlock = (block) => {
+        if (block.size === 0)
+            return -1;
+        const id = blocks.length;
+        blocks.push(block);
+        for (const s of block)
+            blockOf.set(s, id);
+        return id;
+    };
+    pushBlock(finals);
+    pushBlock(nonFinals);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (let i = 0; i < blocks.length; i++) {
+            const B = blocks[i];
+            if (!B || B.size < 2)
+                continue;
+            // Particionar B agrupando por la firma (δ(s, a) → blockId) para todos los símbolos.
+            const signatureMap = new Map();
+            for (const s of B) {
+                const sig = [];
+                const row = total.transitions.get(s);
+                for (const a of total.alphabet) {
+                    const dst = row?.get(a);
+                    const bId = dst !== undefined ? (blockOf.get(dst) ?? -1) : -1;
+                    sig.push(`${a}->${bId}`);
+                }
+                const key = sig.join('|');
+                let bucket = signatureMap.get(key);
+                if (!bucket) {
+                    bucket = new Set();
+                    signatureMap.set(key, bucket);
+                }
+                bucket.add(s);
+            }
+            if (signatureMap.size > 1) {
+                // Reemplazar B por el primer subbloque y agregar el resto.
+                const iter = signatureMap.values();
+                const first = iter.next().value;
+                blocks[i] = first;
+                for (const s of first)
+                    blockOf.set(s, i);
+                let next = iter.next();
+                while (!next.done) {
+                    pushBlock(next.value);
+                    next = iter.next();
+                }
+                changed = true;
+            }
+        }
+    }
+    // Construir DFA minimizado.
+    const newStates = new Set();
+    const newTransitions = new Map();
+    const newAccept = new Set();
+    const blockName = (id) => `q${id}`;
+    for (let i = 0; i < blocks.length; i++) {
+        const b = blocks[i];
+        if (!b || b.size === 0)
+            continue;
+        const name = blockName(i);
+        newStates.add(name);
+        // Representante para acceptación / aristas: cualquier elemento.
+        const rep = b.values().next().value;
+        if (total.accept.has(rep))
+            newAccept.add(name);
+        const row = new Map();
+        const oldRow = total.transitions.get(rep);
+        for (const a of total.alphabet) {
+            const dst = oldRow?.get(a);
+            if (dst !== undefined) {
+                const bId = blockOf.get(dst);
+                if (bId !== undefined)
+                    row.set(a, blockName(bId));
+            }
+        }
+        newTransitions.set(name, row);
+    }
+    const initialBlock = blockOf.get(total.initial);
+    if (initialBlock === undefined) {
+        throw new Error('dfaMinimize: estado inicial sin bloque (estado bug)');
+    }
+    // Eliminar el sink state si no es necesario para reconocer L(M):
+    // sólo lo quitamos si su bloque no contiene aristas entrantes desde
+    // estados accept. (En la práctica lo dejamos: complement lo necesita).
+    return {
+        states: newStates,
+        alphabet: new Set(total.alphabet),
+        transitions: newTransitions,
+        initial: blockName(initialBlock),
+        accept: newAccept,
+    };
+}
+//# sourceMappingURL=dfa.js.map

package/dist/reasoning/automata/dfa.js.map

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

package/dist/reasoning/automata/index.d.ts

@@ -0,0 +1,8 @@
+export { EPSILON } from './types';
+export type { DFA, NFA, PDA, PDATransition, Regex, Symbol } from './types';
+export { dfaAccepts, dfaMinimize, dfaComplement, dfaProduct, dfaUnion, dfaIntersection, dfaTotalize, } from './dfa';
+export { nfaAccepts, nfaToDfa, epsilonClosure } from './nfa';
+export { parseRegex, regexToNfa, regexMatches } from './regex';
+export { pdaAccepts, pdaPalindromes, pdaBalancedParens } from './pda';
+export { dfaEvenZeros, dfaContainsAB, regexEmail } from './languages';
+//# sourceMappingURL=index.d.ts.map

package/dist/reasoning/automata/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/reasoning/automata/index.ts"],"names":[],"mappings":"AAmCA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAClC,YAAY,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAE3E,OAAO,EACL,UAAU,EACV,WAAW,EACX,aAAa,EACb,UAAU,EACV,QAAQ,EACR,eAAe,EACf,WAAW,GACZ,MAAM,OAAO,CAAC;AAEf,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAE7D,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE/D,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAEtE,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC"}

package/dist/reasoning/automata/index.js

@@ -0,0 +1,64 @@
+"use strict";
+// ============================================================
+// ST Automata — Barrel
+// ============================================================
+//
+// Teoría clásica de autómatas:
+//
+//   DFA (Deterministic Finite Automaton)
+//     · dfaAccepts          simulación
+//     · dfaMinimize         Hopcroft partition refinement
+//     · dfaUnion/dfaIntersection/dfaComplement
+//
+//   NFA (con ε-transiciones)
+//     · nfaAccepts          BFS sobre el frontier
+//     · nfaToDfa            subset construction
+//     · epsilonClosure
+//
+//   Regex
+//     · parseRegex          gramática '|', concat, *, +, ?, (), \\esc
+//     · regexToNfa          Thompson construction
+//     · regexMatches        match exacto
+//
+//   PDA (push-down)
+//     · pdaAccepts          BFS no determinista con memo
+//     · pdaPalindromes      palíndromes sobre {a,b}
+//     · pdaBalancedParens   paréntesis balanceados
+//
+//   Lenguajes estándar:
+//     · dfaEvenZeros        {0,1}* con # de '0' par
+//     · dfaContainsAB       {a,b,c}* que contienen "ab"
+//     · regexEmail          regex simplificada de email
+//
+// Constantes:
+//   · EPSILON = 'ε'
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.regexEmail = exports.dfaContainsAB = exports.dfaEvenZeros = exports.pdaBalancedParens = exports.pdaPalindromes = exports.pdaAccepts = exports.regexMatches = exports.regexToNfa = exports.parseRegex = exports.epsilonClosure = exports.nfaToDfa = exports.nfaAccepts = exports.dfaTotalize = exports.dfaIntersection = exports.dfaUnion = exports.dfaProduct = exports.dfaComplement = exports.dfaMinimize = exports.dfaAccepts = exports.EPSILON = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "EPSILON", { enumerable: true, get: function () { return types_1.EPSILON; } });
+var dfa_1 = require("./dfa");
+Object.defineProperty(exports, "dfaAccepts", { enumerable: true, get: function () { return dfa_1.dfaAccepts; } });
+Object.defineProperty(exports, "dfaMinimize", { enumerable: true, get: function () { return dfa_1.dfaMinimize; } });
+Object.defineProperty(exports, "dfaComplement", { enumerable: true, get: function () { return dfa_1.dfaComplement; } });
+Object.defineProperty(exports, "dfaProduct", { enumerable: true, get: function () { return dfa_1.dfaProduct; } });
+Object.defineProperty(exports, "dfaUnion", { enumerable: true, get: function () { return dfa_1.dfaUnion; } });
+Object.defineProperty(exports, "dfaIntersection", { enumerable: true, get: function () { return dfa_1.dfaIntersection; } });
+Object.defineProperty(exports, "dfaTotalize", { enumerable: true, get: function () { return dfa_1.dfaTotalize; } });
+var nfa_1 = require("./nfa");
+Object.defineProperty(exports, "nfaAccepts", { enumerable: true, get: function () { return nfa_1.nfaAccepts; } });
+Object.defineProperty(exports, "nfaToDfa", { enumerable: true, get: function () { return nfa_1.nfaToDfa; } });
+Object.defineProperty(exports, "epsilonClosure", { enumerable: true, get: function () { return nfa_1.epsilonClosure; } });
+var regex_1 = require("./regex");
+Object.defineProperty(exports, "parseRegex", { enumerable: true, get: function () { return regex_1.parseRegex; } });
+Object.defineProperty(exports, "regexToNfa", { enumerable: true, get: function () { return regex_1.regexToNfa; } });
+Object.defineProperty(exports, "regexMatches", { enumerable: true, get: function () { return regex_1.regexMatches; } });
+var pda_1 = require("./pda");
+Object.defineProperty(exports, "pdaAccepts", { enumerable: true, get: function () { return pda_1.pdaAccepts; } });
+Object.defineProperty(exports, "pdaPalindromes", { enumerable: true, get: function () { return pda_1.pdaPalindromes; } });
+Object.defineProperty(exports, "pdaBalancedParens", { enumerable: true, get: function () { return pda_1.pdaBalancedParens; } });
+var languages_1 = require("./languages");
+Object.defineProperty(exports, "dfaEvenZeros", { enumerable: true, get: function () { return languages_1.dfaEvenZeros; } });
+Object.defineProperty(exports, "dfaContainsAB", { enumerable: true, get: function () { return languages_1.dfaContainsAB; } });
+Object.defineProperty(exports, "regexEmail", { enumerable: true, get: function () { return languages_1.regexEmail; } });
+//# sourceMappingURL=index.js.map

package/dist/reasoning/automata/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/reasoning/automata/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,uBAAuB;AACvB,+DAA+D;AAC/D,EAAE;AACF,+BAA+B;AAC/B,EAAE;AACF,yCAAyC;AACzC,uCAAuC;AACvC,0DAA0D;AAC1D,+CAA+C;AAC/C,EAAE;AACF,6BAA6B;AAC7B,kDAAkD;AAClD,gDAAgD;AAChD,uBAAuB;AACvB,EAAE;AACF,UAAU;AACV,sEAAsE;AACtE,kDAAkD;AAClD,yCAAyC;AACzC,EAAE;AACF,oBAAoB;AACpB,yDAAyD;AACzD,oDAAoD;AACpD,mDAAmD;AACnD,EAAE;AACF,wBAAwB;AACxB,oDAAoD;AACpD,wDAAwD;AACxD,wDAAwD;AACxD,EAAE;AACF,cAAc;AACd,oBAAoB;AACpB,+DAA+D;;;AAE/D,iCAAkC;AAAzB,gGAAA,OAAO,OAAA;AAGhB,6BAQe;AAPb,iGAAA,UAAU,OAAA;AACV,kGAAA,WAAW,OAAA;AACX,oGAAA,aAAa,OAAA;AACb,iGAAA,UAAU,OAAA;AACV,+FAAA,QAAQ,OAAA;AACR,sGAAA,eAAe,OAAA;AACf,kGAAA,WAAW,OAAA;AAGb,6BAA6D;AAApD,iGAAA,UAAU,OAAA;AAAE,+FAAA,QAAQ,OAAA;AAAE,qGAAA,cAAc,OAAA;AAE7C,iCAA+D;AAAtD,mGAAA,UAAU,OAAA;AAAE,mGAAA,UAAU,OAAA;AAAE,qGAAA,YAAY,OAAA;AAE7C,6BAAsE;AAA7D,iGAAA,UAAU,OAAA;AAAE,qGAAA,cAAc,OAAA;AAAE,wGAAA,iBAAiB,OAAA;AAEtD,yCAAsE;AAA7D,yGAAA,YAAY,OAAA;AAAE,0GAAA,aAAa,OAAA;AAAE,uGAAA,UAAU,OAAA"}

package/dist/reasoning/automata/languages.d.ts

@@ -0,0 +1,10 @@
+import type { DFA, Regex } from './types';
+/** Palabras sobre {0,1} con un número par de ceros. */
+export declare function dfaEvenZeros(): DFA;
+/** Palabras sobre {a,b,c} que contienen "ab" como subcadena. */
+export declare function dfaContainsAB(): DFA;
+/** Regex simplificada de email: letras+ '@' letras+ '.' letras+
+ *  (ASCII inferior, sin números / símbolos). Es deliberadamente
+ *  pedagógica; no aspira a RFC 5322. */
+export declare function regexEmail(): Regex;
+//# sourceMappingURL=languages.d.ts.map

package/dist/reasoning/automata/languages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"languages.d.ts","sourceRoot":"","sources":["../../../src/reasoning/automata/languages.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,GAAG,EAAE,KAAK,EAAU,MAAM,SAAS,CAAC;AAGlD,uDAAuD;AACvD,wBAAgB,YAAY,IAAI,GAAG,CAyBlC;AAED,gEAAgE;AAChE,wBAAgB,aAAa,IAAI,GAAG,CAmCnC;AAED;;wCAEwC;AACxC,wBAAgB,UAAU,IAAI,KAAK,CASlC"}

package/dist/reasoning/automata/languages.js

@@ -0,0 +1,78 @@
+"use strict";
+// ============================================================
+// ST Automata — Lenguajes estándar de fábrica
+// ============================================================
+//
+// DFAs / regex de ejemplo, útiles para tests y demos:
+//   · dfaEvenZeros()   — palabras sobre {0,1} con número par de '0'.
+//   · dfaContainsAB()  — palabras sobre {a,b,c} que contienen "ab".
+//   · regexEmail()     — regex simplificada de email.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dfaEvenZeros = dfaEvenZeros;
+exports.dfaContainsAB = dfaContainsAB;
+exports.regexEmail = regexEmail;
+const regex_1 = require("./regex");
+/** Palabras sobre {0,1} con un número par de ceros. */
+function dfaEvenZeros() {
+    const states = new Set(['even', 'odd']);
+    const alphabet = new Set(['0', '1']);
+    const transitions = new Map();
+    transitions.set('even', new Map([
+        ['0', 'odd'],
+        ['1', 'even'],
+    ]));
+    transitions.set('odd', new Map([
+        ['0', 'even'],
+        ['1', 'odd'],
+    ]));
+    return {
+        states,
+        alphabet,
+        transitions,
+        initial: 'even',
+        accept: new Set(['even']),
+    };
+}
+/** Palabras sobre {a,b,c} que contienen "ab" como subcadena. */
+function dfaContainsAB() {
+    const states = new Set(['q0', 'q1', 'q2']);
+    const alphabet = new Set(['a', 'b', 'c']);
+    const transitions = new Map();
+    transitions.set('q0', new Map([
+        ['a', 'q1'],
+        ['b', 'q0'],
+        ['c', 'q0'],
+    ]));
+    transitions.set('q1', new Map([
+        ['a', 'q1'],
+        ['b', 'q2'],
+        ['c', 'q0'],
+    ]));
+    transitions.set('q2', new Map([
+        ['a', 'q2'],
+        ['b', 'q2'],
+        ['c', 'q2'],
+    ]));
+    return {
+        states,
+        alphabet,
+        transitions,
+        initial: 'q0',
+        accept: new Set(['q2']),
+    };
+}
+/** Regex simplificada de email: letras+ '@' letras+ '.' letras+
+ *  (ASCII inferior, sin números / símbolos). Es deliberadamente
+ *  pedagógica; no aspira a RFC 5322. */
+function regexEmail() {
+    // (a|b|...|z)+ @ (a|...|z)+ . (a|...|z)+
+    const letters = [];
+    for (let c = 'a'.charCodeAt(0); c <= 'z'.charCodeAt(0); c++) {
+        letters.push(String.fromCharCode(c));
+    }
+    const alt = letters.join('|');
+    const src = `(${alt})+@(${alt})+\\.(${alt})+`;
+    return (0, regex_1.parseRegex)(src);
+}
+//# sourceMappingURL=languages.js.map

package/dist/reasoning/automata/languages.js.map

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

package/dist/reasoning/automata/nfa.d.ts

@@ -0,0 +1,8 @@
+import type { DFA, NFA } from './types';
+/** Cierre-ε: el menor conjunto T ⊇ S cerrado bajo transiciones ε. */
+export declare function epsilonClosure(M: NFA, states: ReadonlySet<string>): Set<string>;
+export declare function nfaAccepts(M: NFA, input: string): boolean;
+/** Subset construction: cada estado del DFA = subconjunto cerrado por ε
+ *  de estados del NFA. Sólo se generan estados alcanzables. */
+export declare function nfaToDfa(M: NFA): DFA;
+//# sourceMappingURL=nfa.d.ts.map

package/dist/reasoning/automata/nfa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nfa.d.ts","sourceRoot":"","sources":["../../../src/reasoning/automata/nfa.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,GAAG,EAAE,GAAG,EAAU,MAAM,SAAS,CAAC;AAKhD,qEAAqE;AACrE,wBAAgB,cAAc,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAmB/E;AAgBD,wBAAgB,UAAU,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAQzD;AAED;+DAC+D;AAC/D,wBAAgB,QAAQ,CAAC,CAAC,EAAE,GAAG,GAAG,GAAG,CAkDpC"}