@stevenvo780/st-lang 4.2.0 → 4.4.0

package/dist/runtime/theorem-cache/cache.js

@@ -0,0 +1,213 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TheoremCache = void 0;
+exports.tryReuseProof = tryReuseProof;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const crypto_1 = require("crypto");
+const canonical_1 = require("./canonical");
+const pattern_1 = require("./pattern");
+function defaultPersistPath() {
+    return path_1.default.join(os_1.default.homedir(), '.st-theorem-cache', 'theorems.json');
+}
+function defaultHash(input) {
+    return (0, crypto_1.createHash)('sha1').update(input).digest('hex');
+}
+class TheoremCache {
+    maxEntries;
+    persistPath;
+    hashFn;
+    entries = new Map();
+    hits = 0;
+    misses = 0;
+    constructor(opts) {
+        this.maxEntries = opts?.maxEntries ?? 10000;
+        this.persistPath = opts?.persistPath ?? defaultPersistPath();
+        this.hashFn = opts?.hashFn ?? defaultHash;
+    }
+    /**
+     * Canonicaliza una fórmula a forma estable (placeholders).
+     */
+    canonicalize(formula) {
+        return (0, canonical_1.canonicalize)(formula).canonical;
+    }
+    /**
+     * Almacena un teorema; retorna el id asignado. Si ya existe una
+     * entrada con el mismo (formula canónica, profile), la reemplaza
+     * y la promueve a MRU.
+     */
+    store(theorem) {
+        const normalized = theorem.normalizedFormula && theorem.normalizedFormula.length > 0
+            ? theorem.normalizedFormula
+            : this.canonicalize(theorem.formula);
+        const id = this.hashFn(`${theorem.profile}::${normalized}`);
+        const full = { ...theorem, normalizedFormula: normalized, id };
+        if (this.entries.has(id)) {
+            this.entries.delete(id);
+        }
+        else if (this.entries.size >= this.maxEntries) {
+            this.evictLru();
+        }
+        this.entries.set(id, { theorem: full });
+        return id;
+    }
+    /**
+     * Devuelve el teorema cacheado para una fórmula+profile dados, o
+     * `undefined` si no existe. Incrementa hits/misses.
+     */
+    retrieve(formula, profile) {
+        const normalized = this.canonicalize(formula);
+        const id = this.hashFn(`${profile}::${normalized}`);
+        const entry = this.entries.get(id);
+        if (entry === undefined) {
+            this.misses++;
+            return undefined;
+        }
+        this.hits++;
+        // LRU promote.
+        this.entries.delete(id);
+        this.entries.set(id, entry);
+        return entry.theorem;
+    }
+    /**
+     * Retorna todos los teoremas que matchean el patrón dado.
+     *
+     * El patrón usa metavariables `?x`. Ej: `?x -> ?x` matchea cualquier
+     * teorema cacheado cuya fórmula sea `<id> -> <id>` (mismo lado).
+     *
+     * El matching opera sobre la fórmula original (no la canónica), de
+     * modo que el caller puede inspeccionar los nombres reales.
+     */
+    retrieveByPattern(pattern) {
+        const out = [];
+        for (const { theorem } of this.entries.values()) {
+            if ((0, pattern_1.matchPattern)(pattern, theorem.formula) !== undefined) {
+                out.push(theorem);
+            }
+        }
+        return out;
+    }
+    /**
+     * Comprueba si existe una entrada para (formula, profile). NO afecta
+     * los contadores hits/misses.
+     */
+    exists(formula, profile) {
+        const normalized = this.canonicalize(formula);
+        const id = this.hashFn(`${profile}::${normalized}`);
+        return this.entries.has(id);
+    }
+    remove(id) {
+        return this.entries.delete(id);
+    }
+    clear() {
+        this.entries.clear();
+        this.hits = 0;
+        this.misses = 0;
+    }
+    async saveToDisk() {
+        const dir = path_1.default.dirname(this.persistPath);
+        await fs_1.promises.mkdir(dir, { recursive: true });
+        const payload = [];
+        for (const { theorem } of this.entries.values())
+            payload.push(theorem);
+        await fs_1.promises.writeFile(this.persistPath, JSON.stringify(payload), 'utf-8');
+    }
+    /**
+     * Carga teoremas desde disco. Devuelve cuántas entradas cargó.
+     * No-op silencioso si el archivo no existe.
+     */
+    async loadFromDisk() {
+        let raw;
+        try {
+            raw = await fs_1.promises.readFile(this.persistPath, 'utf-8');
+        }
+        catch {
+            return 0;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return 0;
+        }
+        if (!Array.isArray(parsed))
+            return 0;
+        let loaded = 0;
+        for (const item of parsed) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const t = item;
+            if (typeof t.id !== 'string' ||
+                typeof t.formula !== 'string' ||
+                typeof t.normalizedFormula !== 'string' ||
+                typeof t.profile !== 'string' ||
+                !t.metadata ||
+                typeof t.metadata !== 'object') {
+                continue;
+            }
+            if (this.entries.has(t.id))
+                continue;
+            if (this.entries.size >= this.maxEntries)
+                break;
+            this.entries.set(t.id, { theorem: t });
+            loaded++;
+        }
+        return loaded;
+    }
+    stats() {
+        let bytes = 0;
+        for (const { theorem } of this.entries.values()) {
+            bytes += JSON.stringify(theorem).length;
+        }
+        return {
+            entries: this.entries.size,
+            hits: this.hits,
+            misses: this.misses,
+            storedBytes: bytes,
+        };
+    }
+    evictLru() {
+        const firstKey = this.entries.keys().next().value;
+        if (firstKey !== undefined)
+            this.entries.delete(firstKey);
+    }
+}
+exports.TheoremCache = TheoremCache;
+/**
+ * Intenta reusar la prueba de un teorema cacheado para un target
+ * dado. Si las fórmulas son canónicamente equivalentes (misma
+ * estructura, identificadores en el mismo orden), calcula la
+ * substitución y reemplaza los nombres en la prueba (cuando la
+ * prueba es un string o un objeto JSON que la admita textualmente).
+ *
+ * Para pruebas opacas no-string, devuelve la prueba original sin
+ * tocar — el caller es responsable de re-instanciar.
+ */
+function tryReuseProof(theorem, targetFormula) {
+    const substitution = (0, canonical_1.computeSubstitution)(theorem.formula, targetFormula);
+    if (substitution === undefined) {
+        return { reusable: false };
+    }
+    let reusedProof = theorem.proof;
+    if (typeof theorem.proof === 'string') {
+        reusedProof = (0, canonical_1.applySubstitution)(theorem.proof, substitution);
+    }
+    else if (theorem.proof && typeof theorem.proof === 'object') {
+        // Substitución textual sobre la serialización JSON.
+        try {
+            const serialized = JSON.stringify(theorem.proof);
+            const rewritten = (0, canonical_1.applySubstitution)(serialized, substitution);
+            reusedProof = JSON.parse(rewritten);
+        }
+        catch {
+            reusedProof = theorem.proof;
+        }
+    }
+    return { reusable: true, substitution, reusedProof };
+}
+//# sourceMappingURL=cache.js.map

package/dist/runtime/theorem-cache/cache.js.map

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

package/dist/runtime/theorem-cache/canonical.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Canonicalización de fórmulas (string-based) para el theorem cache.
+ *
+ * El objetivo no es parsear lógica completa, sino normalizar:
+ * - whitespace
+ * - mapear identificadores (átomos / metavariables) a placeholders
+ *   canónicos en orden de primera aparición, preservando estructura.
+ *
+ * Resultado: `P -> P` y `Q -> Q` producen la misma forma canónica
+ * (`?0 -> ?0`), mientras que `P -> Q` produce `?0 -> ?1`. Esto soporta
+ * proof reuse via substitución.
+ *
+ * Símbolos lógicos reservados (palabras clave) NO se renombran:
+ *   not, and, or, implies, iff, forall, exists, true, false, ->,
+ *   →, ∧, ∨, ¬, ↔, ∀, ∃, ⊤, ⊥
+ */
+/**
+ * Normaliza whitespace: colapsa runs de espacio/tabs/newlines a un solo
+ * espacio, y trimea. Mantiene la separación de tokens.
+ */
+export declare function normalizeWhitespace(formula: string): string;
+/**
+ * Devuelve la forma canónica de una fórmula como string.
+ *
+ * Cada identificador no reservado se reemplaza por `?N` donde N es el
+ * orden de primera aparición. La estructura (operadores, paréntesis,
+ * cuantificadores) se preserva intacta tras normalizar whitespace.
+ *
+ * También devuelve el mapping inverso (canonical → original) para
+ * poder reconstruir substituciones.
+ */
+export interface CanonicalResult {
+    canonical: string;
+    /** Mapping de original → placeholder. Ej: `{P: "?0", Q: "?1"}` */
+    forward: Map<string, string>;
+    /** Mapping de placeholder → original. Ej: `{"?0": "P", "?1": "Q"}` */
+    reverse: Map<string, string>;
+}
+export declare function canonicalize(formula: string): CanonicalResult;
+/**
+ * Versión simple que sólo devuelve el string canónico.
+ */
+export declare function canonicalString(formula: string): string;
+/**
+ * Intenta encontrar una substitución que mapee la fórmula cacheada
+ * al target. Si las formas canónicas coinciden, calcula el mapping
+ * desde los identificadores originales del teorema hacia los del
+ * target.
+ *
+ * Retorna `undefined` si no son canónicamente equivalentes.
+ */
+export declare function computeSubstitution(cachedFormula: string, targetFormula: string): Record<string, string> | undefined;
+/**
+ * Aplica una substitución textual (mapping original → reemplazo) a
+ * una fórmula, respetando límites de identificador. Útil para
+ * rehidratar pruebas reutilizadas.
+ */
+export declare function applySubstitution(formula: string, substitution: Record<string, string>): string;
+//# sourceMappingURL=canonical.d.ts.map

package/dist/runtime/theorem-cache/canonical.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical.d.ts","sourceRoot":"","sources":["../../../src/runtime/theorem-cache/canonical.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAoBH;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,kEAAkE;IAClE,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,sEAAsE;IACtE,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9B;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,CAkB7D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,GACpB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAapC;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAK/F"}

package/dist/runtime/theorem-cache/canonical.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * Canonicalización de fórmulas (string-based) para el theorem cache.
+ *
+ * El objetivo no es parsear lógica completa, sino normalizar:
+ * - whitespace
+ * - mapear identificadores (átomos / metavariables) a placeholders
+ *   canónicos en orden de primera aparición, preservando estructura.
+ *
+ * Resultado: `P -> P` y `Q -> Q` producen la misma forma canónica
+ * (`?0 -> ?0`), mientras que `P -> Q` produce `?0 -> ?1`. Esto soporta
+ * proof reuse via substitución.
+ *
+ * Símbolos lógicos reservados (palabras clave) NO se renombran:
+ *   not, and, or, implies, iff, forall, exists, true, false, ->,
+ *   →, ∧, ∨, ¬, ↔, ∀, ∃, ⊤, ⊥
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeWhitespace = normalizeWhitespace;
+exports.canonicalize = canonicalize;
+exports.canonicalString = canonicalString;
+exports.computeSubstitution = computeSubstitution;
+exports.applySubstitution = applySubstitution;
+const RESERVED = new Set([
+    'not',
+    'and',
+    'or',
+    'implies',
+    'iff',
+    'forall',
+    'exists',
+    'true',
+    'false',
+    'True',
+    'False',
+    'TRUE',
+    'FALSE',
+]);
+const IDENT_RE = /[A-Za-z_][A-Za-z0-9_]*/g;
+/**
+ * Normaliza whitespace: colapsa runs de espacio/tabs/newlines a un solo
+ * espacio, y trimea. Mantiene la separación de tokens.
+ */
+function normalizeWhitespace(formula) {
+    return formula.replace(/\s+/g, ' ').trim();
+}
+function canonicalize(formula) {
+    const normalized = normalizeWhitespace(formula);
+    const forward = new Map();
+    const reverse = new Map();
+    let counter = 0;
+    const canonical = normalized.replace(IDENT_RE, (match) => {
+        if (RESERVED.has(match))
+            return match;
+        let placeholder = forward.get(match);
+        if (placeholder === undefined) {
+            placeholder = `?${counter++}`;
+            forward.set(match, placeholder);
+            reverse.set(placeholder, match);
+        }
+        return placeholder;
+    });
+    return { canonical, forward, reverse };
+}
+/**
+ * Versión simple que sólo devuelve el string canónico.
+ */
+function canonicalString(formula) {
+    return canonicalize(formula).canonical;
+}
+/**
+ * Intenta encontrar una substitución que mapee la fórmula cacheada
+ * al target. Si las formas canónicas coinciden, calcula el mapping
+ * desde los identificadores originales del teorema hacia los del
+ * target.
+ *
+ * Retorna `undefined` si no son canónicamente equivalentes.
+ */
+function computeSubstitution(cachedFormula, targetFormula) {
+    const c1 = canonicalize(cachedFormula);
+    const c2 = canonicalize(targetFormula);
+    if (c1.canonical !== c2.canonical)
+        return undefined;
+    const substitution = {};
+    for (const [original, placeholder] of c1.forward) {
+        const targetOriginal = c2.reverse.get(placeholder);
+        if (targetOriginal === undefined)
+            return undefined;
+        substitution[original] = targetOriginal;
+    }
+    return substitution;
+}
+/**
+ * Aplica una substitución textual (mapping original → reemplazo) a
+ * una fórmula, respetando límites de identificador. Útil para
+ * rehidratar pruebas reutilizadas.
+ */
+function applySubstitution(formula, substitution) {
+    return formula.replace(IDENT_RE, (match) => {
+        if (RESERVED.has(match))
+            return match;
+        return substitution[match] ?? match;
+    });
+}
+//# sourceMappingURL=canonical.js.map

package/dist/runtime/theorem-cache/canonical.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical.js","sourceRoot":"","sources":["../../../src/runtime/theorem-cache/canonical.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;AAwBH,kDAEC;AAoBD,oCAkBC;AAKD,0CAEC;AAUD,kDAgBC;AAOD,8CAKC;AA3GD,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAS;IAC/B,KAAK;IACL,KAAK;IACL,IAAI;IACJ,SAAS;IACT,KAAK;IACL,QAAQ;IACR,QAAQ;IACR,MAAM;IACN,OAAO;IACP,MAAM;IACN,OAAO;IACP,MAAM;IACN,OAAO;CACR,CAAC,CAAC;AAEH,MAAM,QAAQ,GAAG,yBAAyB,CAAC;AAE3C;;;GAGG;AACH,SAAgB,mBAAmB,CAAC,OAAe;IACjD,OAAO,OAAO,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;AAC7C,CAAC;AAoBD,SAAgB,YAAY,CAAC,OAAe;IAC1C,MAAM,UAAU,GAAG,mBAAmB,CAAC,OAAO,CAAC,CAAC;IAChD,MAAM,OAAO,GAAG,IAAI,GAAG,EAAkB,CAAC;IAC1C,MAAM,OAAO,GAAG,IAAI,GAAG,EAAkB,CAAC;IAC1C,IAAI,OAAO,GAAG,CAAC,CAAC;IAEhB,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,EAAE;QACvD,IAAI,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QACtC,IAAI,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACrC,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC9B,WAAW,GAAG,IAAI,OAAO,EAAE,EAAE,CAAC;YAC9B,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;YAChC,OAAO,CAAC,GAAG,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;QAClC,CAAC;QACD,OAAO,WAAW,CAAC;IACrB,CAAC,CAAC,CAAC;IAEH,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;AACzC,CAAC;AAED;;GAEG;AACH,SAAgB,eAAe,CAAC,OAAe;IAC7C,OAAO,YAAY,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC;AACzC,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,mBAAmB,CACjC,aAAqB,EACrB,aAAqB;IAErB,MAAM,EAAE,GAAG,YAAY,CAAC,aAAa,CAAC,CAAC;IACvC,MAAM,EAAE,GAAG,YAAY,CAAC,aAAa,CAAC,CAAC;IAEvC,IAAI,EAAE,CAAC,SAAS,KAAK,EAAE,CAAC,SAAS;QAAE,OAAO,SAAS,CAAC;IAEpD,MAAM,YAAY,GAA2B,EAAE,CAAC;IAChD,KAAK,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE,CAAC;QACjD,MAAM,cAAc,GAAG,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QACnD,IAAI,cAAc,KAAK,SAAS;YAAE,OAAO,SAAS,CAAC;QACnD,YAAY,CAAC,QAAQ,CAAC,GAAG,cAAc,CAAC;IAC1C,CAAC;IACD,OAAO,YAAY,CAAC;AACtB,CAAC;AAED;;;;GAIG;AACH,SAAgB,iBAAiB,CAAC,OAAe,EAAE,YAAoC;IACrF,OAAO,OAAO,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,EAAE;QACzC,IAAI,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QACtC,OAAO,YAAY,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC;IACtC,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/runtime/theorem-cache/index.d.ts

@@ -0,0 +1,6 @@
+export { TheoremCache, tryReuseProof } from './cache';
+export type { CachedTheorem, CacheOptions, CacheStats, ReuseResult } from './cache';
+export { canonicalize, canonicalString, computeSubstitution, applySubstitution, normalizeWhitespace, } from './canonical';
+export type { CanonicalResult } from './canonical';
+export { matchPattern, patternMatches } from './pattern';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/theorem-cache/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/theorem-cache/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACtD,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AACpF,OAAO,EACL,YAAY,EACZ,eAAe,EACf,mBAAmB,EACnB,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC"}

package/dist/runtime/theorem-cache/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patternMatches = exports.matchPattern = exports.normalizeWhitespace = exports.applySubstitution = exports.computeSubstitution = exports.canonicalString = exports.canonicalize = exports.tryReuseProof = exports.TheoremCache = void 0;
+var cache_1 = require("./cache");
+Object.defineProperty(exports, "TheoremCache", { enumerable: true, get: function () { return cache_1.TheoremCache; } });
+Object.defineProperty(exports, "tryReuseProof", { enumerable: true, get: function () { return cache_1.tryReuseProof; } });
+var canonical_1 = require("./canonical");
+Object.defineProperty(exports, "canonicalize", { enumerable: true, get: function () { return canonical_1.canonicalize; } });
+Object.defineProperty(exports, "canonicalString", { enumerable: true, get: function () { return canonical_1.canonicalString; } });
+Object.defineProperty(exports, "computeSubstitution", { enumerable: true, get: function () { return canonical_1.computeSubstitution; } });
+Object.defineProperty(exports, "applySubstitution", { enumerable: true, get: function () { return canonical_1.applySubstitution; } });
+Object.defineProperty(exports, "normalizeWhitespace", { enumerable: true, get: function () { return canonical_1.normalizeWhitespace; } });
+var pattern_1 = require("./pattern");
+Object.defineProperty(exports, "matchPattern", { enumerable: true, get: function () { return pattern_1.matchPattern; } });
+Object.defineProperty(exports, "patternMatches", { enumerable: true, get: function () { return pattern_1.patternMatches; } });
+//# sourceMappingURL=index.js.map

package/dist/runtime/theorem-cache/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime/theorem-cache/index.ts"],"names":[],"mappings":";;;AAAA,iCAAsD;AAA7C,qGAAA,YAAY,OAAA;AAAE,sGAAA,aAAa,OAAA;AAEpC,yCAMqB;AALnB,yGAAA,YAAY,OAAA;AACZ,4GAAA,eAAe,OAAA;AACf,gHAAA,mBAAmB,OAAA;AACnB,8GAAA,iBAAiB,OAAA;AACjB,gHAAA,mBAAmB,OAAA;AAGrB,qCAAyD;AAAhD,uGAAA,YAAY,OAAA;AAAE,yGAAA,cAAc,OAAA"}

package/dist/runtime/theorem-cache/pattern.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Matching de patrones contra fórmulas cacheadas.
+ *
+ * Un patrón usa `?x`, `?y`, … como metavariables. Para que un patrón
+ * matchee una fórmula, debe existir una asignación consistente
+ * (cada metavariable mapea a un único identificador en la fórmula).
+ *
+ * Ejemplos:
+ *   patrón `?x -> ?x`  matchea  `P -> P`         (con x=P)
+ *   patrón `?x -> ?x`  NO matchea  `P -> Q`
+ *   patrón `?x -> ?y`  matchea  `P -> Q`         (con x=P, y=Q)
+ *   patrón `?x -> ?y`  matchea  `P -> P`         (con x=P, y=P)
+ */
+/**
+ * Intenta matchear un patrón contra una fórmula. Retorna la
+ * asignación de metavariables si matchea, o `undefined` si no.
+ */
+export declare function matchPattern(pattern: string, formula: string): Record<string, string> | undefined;
+/**
+ * Comprueba si un patrón matchea (al menos una vez) sobre la fórmula
+ * completa, sin extraer las bindings.
+ */
+export declare function patternMatches(pattern: string, formula: string): boolean;
+//# sourceMappingURL=pattern.d.ts.map

package/dist/runtime/theorem-cache/pattern.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern.d.ts","sourceRoot":"","sources":["../../../src/runtime/theorem-cache/pattern.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AA4BH;;;GAGG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CA8BjG;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAExE"}

package/dist/runtime/theorem-cache/pattern.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Matching de patrones contra fórmulas cacheadas.
+ *
+ * Un patrón usa `?x`, `?y`, … como metavariables. Para que un patrón
+ * matchee una fórmula, debe existir una asignación consistente
+ * (cada metavariable mapea a un único identificador en la fórmula).
+ *
+ * Ejemplos:
+ *   patrón `?x -> ?x`  matchea  `P -> P`         (con x=P)
+ *   patrón `?x -> ?x`  NO matchea  `P -> Q`
+ *   patrón `?x -> ?y`  matchea  `P -> Q`         (con x=P, y=Q)
+ *   patrón `?x -> ?y`  matchea  `P -> P`         (con x=P, y=P)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchPattern = matchPattern;
+exports.patternMatches = patternMatches;
+const canonical_1 = require("./canonical");
+const RESERVED = new Set([
+    'not',
+    'and',
+    'or',
+    'implies',
+    'iff',
+    'forall',
+    'exists',
+    'true',
+    'false',
+    'True',
+    'False',
+    'TRUE',
+    'FALSE',
+]);
+// Token: meta-variable (?name), identificador, número, símbolo.
+const TOKEN_RE = /\?[A-Za-z_][A-Za-z0-9_]*|[A-Za-z_][A-Za-z0-9_]*|\d+|[^\sA-Za-z0-9_]/g;
+function tokenize(s) {
+    const normalized = (0, canonical_1.normalizeWhitespace)(s);
+    return normalized.match(TOKEN_RE) ?? [];
+}
+/**
+ * Intenta matchear un patrón contra una fórmula. Retorna la
+ * asignación de metavariables si matchea, o `undefined` si no.
+ */
+function matchPattern(pattern, formula) {
+    const patternTokens = tokenize(pattern);
+    const formulaTokens = tokenize(formula);
+    if (patternTokens.length !== formulaTokens.length)
+        return undefined;
+    const bindings = {};
+    for (let i = 0; i < patternTokens.length; i++) {
+        const pt = patternTokens[i];
+        const ft = formulaTokens[i];
+        if (pt.startsWith('?')) {
+            const metaName = pt.slice(1);
+            const existing = bindings[metaName];
+            if (existing === undefined) {
+                // ft debe ser un identificador (no operador / paréntesis).
+                if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(ft) || RESERVED.has(ft)) {
+                    return undefined;
+                }
+                bindings[metaName] = ft;
+            }
+            else if (existing !== ft) {
+                return undefined;
+            }
+        }
+        else if (pt !== ft) {
+            return undefined;
+        }
+    }
+    return bindings;
+}
+/**
+ * Comprueba si un patrón matchea (al menos una vez) sobre la fórmula
+ * completa, sin extraer las bindings.
+ */
+function patternMatches(pattern, formula) {
+    return matchPattern(pattern, formula) !== undefined;
+}
+//# sourceMappingURL=pattern.js.map

package/dist/runtime/theorem-cache/pattern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern.js","sourceRoot":"","sources":["../../../src/runtime/theorem-cache/pattern.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;AAgCH,oCA8BC;AAMD,wCAEC;AApED,2CAAkD;AAElD,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAS;IAC/B,KAAK;IACL,KAAK;IACL,IAAI;IACJ,SAAS;IACT,KAAK;IACL,QAAQ;IACR,QAAQ;IACR,MAAM;IACN,OAAO;IACP,MAAM;IACN,OAAO;IACP,MAAM;IACN,OAAO;CACR,CAAC,CAAC;AAEH,gEAAgE;AAChE,MAAM,QAAQ,GAAG,sEAAsE,CAAC;AAExF,SAAS,QAAQ,CAAC,CAAS;IACzB,MAAM,UAAU,GAAG,IAAA,+BAAmB,EAAC,CAAC,CAAC,CAAC;IAC1C,OAAO,UAAU,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;AAC1C,CAAC;AAED;;;GAGG;AACH,SAAgB,YAAY,CAAC,OAAe,EAAE,OAAe;IAC3D,MAAM,aAAa,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;IACxC,MAAM,aAAa,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;IAExC,IAAI,aAAa,CAAC,MAAM,KAAK,aAAa,CAAC,MAAM;QAAE,OAAO,SAAS,CAAC;IAEpE,MAAM,QAAQ,GAA2B,EAAE,CAAC;IAE5C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC9C,MAAM,EAAE,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;QAC5B,MAAM,EAAE,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;QAE5B,IAAI,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YACvB,MAAM,QAAQ,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAC7B,MAAM,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC;YACpC,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;gBAC3B,2DAA2D;gBAC3D,IAAI,CAAC,0BAA0B,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC;oBAC7D,OAAO,SAAS,CAAC;gBACnB,CAAC;gBACD,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;YAC1B,CAAC;iBAAM,IAAI,QAAQ,KAAK,EAAE,EAAE,CAAC;gBAC3B,OAAO,SAAS,CAAC;YACnB,CAAC;QACH,CAAC;aAAM,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;YACrB,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;GAGG;AACH,SAAgB,cAAc,CAAC,OAAe,EAAE,OAAe;IAC7D,OAAO,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,SAAS,CAAC;AACtD,CAAC"}

package/dist/system-f/index.d.ts

@@ -0,0 +1,7 @@
+export type { FType, FTerm, FContext } from './types';
+export { fAtom, fArrow, fForall, fVar, fAbs, fApp, fTAbs, fTApp, freeTypeVars, alphaEqType, isWellFormed, fTypeToString, fTermToString, emptyContext, cloneContext, } from './types';
+export type { FTypeResult } from './infer';
+export { typeOf, isTypeError } from './infer';
+export type { NormalizeResult } from './reduce';
+export { reduceBeta, normalize, isNormal, freeVars, termTypeVars, substType, substTypeInTerm, substTerm, } from './reduce';
+//# sourceMappingURL=index.d.ts.map

package/dist/system-f/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/system-f/index.ts"],"names":[],"mappings":"AAiBA,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EACL,KAAK,EACL,MAAM,EACN,OAAO,EACP,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,KAAK,EACL,KAAK,EACL,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,aAAa,EACb,aAAa,EACb,YAAY,EACZ,YAAY,GACb,MAAM,SAAS,CAAC;AAEjB,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE9C,YAAY,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,EACL,UAAU,EACV,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,eAAe,EACf,SAAS,GACV,MAAM,UAAU,CAAC"}

package/dist/system-f/index.js

@@ -0,0 +1,48 @@
+"use strict";
+// ============================================================
+// System F — Punto de entrada público
+// ============================================================
+//
+// λ² (System F) extiende STLC con cuantificación universal sobre
+// tipos. Curry-Howard: corresponde a la lógica proposicional
+// intuicionista de segundo orden.
+//
+// Constructores y operaciones:
+//   - Tipos: atom, arrow, forall.
+//   - Términos: var, abs, app, tabs (Λ), tapp (t [T]).
+//   - typeOf: type-checking con contexto (term + type).
+//   - reduceBeta / normalize: β + type-β (call-by-name).
+//   - isWellFormed: chequea que tipos no tengan variables libres
+//     no declaradas.
+//   - alphaEqType: igualdad de tipos módulo α.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.substTerm = exports.substTypeInTerm = exports.substType = exports.termTypeVars = exports.freeVars = exports.isNormal = exports.normalize = exports.reduceBeta = exports.isTypeError = exports.typeOf = exports.cloneContext = exports.emptyContext = exports.fTermToString = exports.fTypeToString = exports.isWellFormed = exports.alphaEqType = exports.freeTypeVars = exports.fTApp = exports.fTAbs = exports.fApp = exports.fAbs = exports.fVar = exports.fForall = exports.fArrow = exports.fAtom = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "fAtom", { enumerable: true, get: function () { return types_1.fAtom; } });
+Object.defineProperty(exports, "fArrow", { enumerable: true, get: function () { return types_1.fArrow; } });
+Object.defineProperty(exports, "fForall", { enumerable: true, get: function () { return types_1.fForall; } });
+Object.defineProperty(exports, "fVar", { enumerable: true, get: function () { return types_1.fVar; } });
+Object.defineProperty(exports, "fAbs", { enumerable: true, get: function () { return types_1.fAbs; } });
+Object.defineProperty(exports, "fApp", { enumerable: true, get: function () { return types_1.fApp; } });
+Object.defineProperty(exports, "fTAbs", { enumerable: true, get: function () { return types_1.fTAbs; } });
+Object.defineProperty(exports, "fTApp", { enumerable: true, get: function () { return types_1.fTApp; } });
+Object.defineProperty(exports, "freeTypeVars", { enumerable: true, get: function () { return types_1.freeTypeVars; } });
+Object.defineProperty(exports, "alphaEqType", { enumerable: true, get: function () { return types_1.alphaEqType; } });
+Object.defineProperty(exports, "isWellFormed", { enumerable: true, get: function () { return types_1.isWellFormed; } });
+Object.defineProperty(exports, "fTypeToString", { enumerable: true, get: function () { return types_1.fTypeToString; } });
+Object.defineProperty(exports, "fTermToString", { enumerable: true, get: function () { return types_1.fTermToString; } });
+Object.defineProperty(exports, "emptyContext", { enumerable: true, get: function () { return types_1.emptyContext; } });
+Object.defineProperty(exports, "cloneContext", { enumerable: true, get: function () { return types_1.cloneContext; } });
+var infer_1 = require("./infer");
+Object.defineProperty(exports, "typeOf", { enumerable: true, get: function () { return infer_1.typeOf; } });
+Object.defineProperty(exports, "isTypeError", { enumerable: true, get: function () { return infer_1.isTypeError; } });
+var reduce_1 = require("./reduce");
+Object.defineProperty(exports, "reduceBeta", { enumerable: true, get: function () { return reduce_1.reduceBeta; } });
+Object.defineProperty(exports, "normalize", { enumerable: true, get: function () { return reduce_1.normalize; } });
+Object.defineProperty(exports, "isNormal", { enumerable: true, get: function () { return reduce_1.isNormal; } });
+Object.defineProperty(exports, "freeVars", { enumerable: true, get: function () { return reduce_1.freeVars; } });
+Object.defineProperty(exports, "termTypeVars", { enumerable: true, get: function () { return reduce_1.termTypeVars; } });
+Object.defineProperty(exports, "substType", { enumerable: true, get: function () { return reduce_1.substType; } });
+Object.defineProperty(exports, "substTypeInTerm", { enumerable: true, get: function () { return reduce_1.substTypeInTerm; } });
+Object.defineProperty(exports, "substTerm", { enumerable: true, get: function () { return reduce_1.substTerm; } });
+//# sourceMappingURL=index.js.map

package/dist/system-f/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/system-f/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,sCAAsC;AACtC,+DAA+D;AAC/D,EAAE;AACF,iEAAiE;AACjE,6DAA6D;AAC7D,kCAAkC;AAClC,EAAE;AACF,+BAA+B;AAC/B,kCAAkC;AAClC,uDAAuD;AACvD,wDAAwD;AACxD,yDAAyD;AACzD,iEAAiE;AACjE,qBAAqB;AACrB,+CAA+C;;;AAG/C,iCAgBiB;AAff,8FAAA,KAAK,OAAA;AACL,+FAAA,MAAM,OAAA;AACN,gGAAA,OAAO,OAAA;AACP,6FAAA,IAAI,OAAA;AACJ,6FAAA,IAAI,OAAA;AACJ,6FAAA,IAAI,OAAA;AACJ,8FAAA,KAAK,OAAA;AACL,8FAAA,KAAK,OAAA;AACL,qGAAA,YAAY,OAAA;AACZ,oGAAA,WAAW,OAAA;AACX,qGAAA,YAAY,OAAA;AACZ,sGAAA,aAAa,OAAA;AACb,sGAAA,aAAa,OAAA;AACb,qGAAA,YAAY,OAAA;AACZ,qGAAA,YAAY,OAAA;AAId,iCAA8C;AAArC,+FAAA,MAAM,OAAA;AAAE,oGAAA,WAAW,OAAA;AAG5B,mCASkB;AARhB,oGAAA,UAAU,OAAA;AACV,mGAAA,SAAS,OAAA;AACT,kGAAA,QAAQ,OAAA;AACR,kGAAA,QAAQ,OAAA;AACR,sGAAA,YAAY,OAAA;AACZ,mGAAA,SAAS,OAAA;AACT,yGAAA,eAAe,OAAA;AACf,mGAAA,SAAS,OAAA"}

package/dist/system-f/infer.d.ts

@@ -0,0 +1,9 @@
+import type { FContext, FTerm, FType } from './types';
+export type FTypeResult = FType | {
+    error: string;
+};
+export declare function isTypeError(r: FTypeResult): r is {
+    error: string;
+};
+export declare function typeOf(term: FTerm, ctx?: FContext): FTypeResult;
+//# sourceMappingURL=infer.d.ts.map

package/dist/system-f/infer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infer.d.ts","sourceRoot":"","sources":["../../src/system-f/infer.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAItD,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpD,wBAAgB,WAAW,CAAC,CAAC,EAAE,WAAW,GAAG,CAAC,IAAI;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAElE;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,GAAE,QAAyB,GAAG,WAAW,CAyE/E"}