@stevenvo780/st-lang 4.14.0 → 4.15.0

package/dist/reasoning/proof-mining/generalizer.js

@@ -0,0 +1,245 @@
+"use strict";
+// ============================================================
+// ST Proof Mining — Generalización de lemmas vía anti-unification
+// ============================================================
+//
+// Después de extraer sub-trees con la misma forma estructural (la
+// clave canónica los agrupa), queremos producir UN statement
+// generalizado que represente al grupo.
+//
+// Ejemplo concreto:
+//   - Proof A contiene sub-tree concluyendo  `P -> P`
+//   - Proof B contiene sub-tree concluyendo  `Q -> Q`
+//   - Proof C contiene sub-tree concluyendo  `R -> R`
+// El statement generalizado debería ser `?x -> ?x` (reflexividad
+// de la implicación, instancia del lemma “identity”).
+//
+// Para términos de primer orden (e.g. árboles AST), usamos el
+// algoritmo de Plotkin del módulo runtime/anti-unification.
+//
+// Para strings (caso conclusión sin parser), aproximamos el lgg
+// posicional: tokenizamos por whitespace + tokens-básicos, alineamos
+// el array y reemplazamos los desacuerdos por placeholders fresh.
+// Es una aproximación pragmática suficiente para conclusiones de
+// fórmulas; quien quiera lgg sobre árboles AST puede ir directo a
+// `antiUnifyMany` del runtime y feedearlo.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generalizeTerms = generalizeTerms;
+exports.generalizeFormulas = generalizeFormulas;
+exports.generalizeLemma = generalizeLemma;
+const anti_unification_1 = require("../../runtime/anti-unification");
+/**
+ * Generaliza una lista de instancias concretas vía anti-unification
+ * sobre términos. Útil cuando el caller ya parsea fórmulas a un AST
+ * `Term`.
+ */
+function generalizeTerms(instances, freshSupply) {
+    if (instances.length === 0) {
+        return { statement: '', abstractionLevel: 0, nonTrivial: false };
+    }
+    if (instances.length === 1) {
+        const t = instances[0];
+        if (t === undefined) {
+            return { statement: '', abstractionLevel: 0, nonTrivial: false };
+        }
+        return { statement: termToReadable(t), abstractionLevel: 0, nonTrivial: false };
+    }
+    const supply = freshSupply ?? (0, anti_unification_1.defaultFreshSupply)('?');
+    const result = (0, anti_unification_1.antiUnifyMany)(instances, supply);
+    return {
+        statement: termToReadable(result.generalization),
+        abstractionLevel: result.variables.length,
+        nonTrivial: result.variables.length > 0,
+    };
+}
+/**
+ * Render legible de un Term (compatible con la convención de
+ * lemma-synthesis: var/const → name, func → name(args)).
+ */
+function termToReadable(t) {
+    if (t.kind === 'var')
+        return t.name;
+    if (t.kind === 'const')
+        return t.name;
+    const args = t.args ?? [];
+    if (args.length === 0)
+        return t.name;
+    // Operadores binarios infijos
+    if (args.length === 2 && /^[+\-*/^∧∨↔→=<>≤≥&|]+$/.test(t.name)) {
+        const a0 = args[0];
+        const a1 = args[1];
+        if (a0 === undefined || a1 === undefined)
+            return t.name;
+        return `(${termToReadable(a0)} ${t.name} ${termToReadable(a1)})`;
+    }
+    return `${t.name}(${args.map(termToReadable).join(', ')})`;
+}
+// ── Generalización por tokens (sin parsear AST) ─────────────────
+/**
+ * Tokeniza una fórmula para alineamiento posicional. Mantiene los
+ * operadores como tokens propios.
+ */
+function tokenize(s) {
+    // Separa identificadores y operadores; ignora whitespace.
+    const out = [];
+    const re = /[A-Za-z_][A-Za-z0-9_]*|->|→|<->|↔|\(|\)|,|[¬∧∨∀∃⊤⊥=]|[^\sA-Za-z0-9_(),→↔¬∧∨∀∃⊤⊥=]+/g;
+    let m;
+    while ((m = re.exec(s)) !== null) {
+        out.push(m[0]);
+    }
+    return out;
+}
+const IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const RESERVED = new Set([
+    'not',
+    'and',
+    'or',
+    'implies',
+    'iff',
+    'forall',
+    'exists',
+    'true',
+    'false',
+]);
+/**
+ * Generaliza una lista de fórmulas string. Tokeniza, alinea
+ * posicionalmente, y donde haya desacuerdo introduce un placeholder
+ * fresh. Si la tokenización produce arrays de distinta longitud, no
+ * intenta align: devuelve el primer string y nonTrivial = false.
+ *
+ * Tabla de desacuerdos: si el mismo par (a, b) reaparece, recibe el
+ * mismo placeholder (consistencia, propiedad LGG).
+ *
+ * Para igualar reservadas (operadores, paréntesis) en todas las
+ * instancias, esas posiciones se mantienen literales. Solo los
+ * tokens-identificador se generalizan.
+ */
+function generalizeFormulas(instances) {
+    if (instances.length === 0) {
+        return { statement: '', abstractionLevel: 0, nonTrivial: false };
+    }
+    if (instances.length === 1) {
+        const s = instances[0];
+        return { statement: s ?? '', abstractionLevel: 0, nonTrivial: false };
+    }
+    const tokenized = instances.map(tokenize);
+    const len = tokenized[0]?.length ?? 0;
+    for (const t of tokenized) {
+        if (t.length !== len) {
+            // No alineable: caemos al canonical string como aproximación.
+            return {
+                statement: instances[0] ?? '',
+                abstractionLevel: 0,
+                nonTrivial: false,
+            };
+        }
+    }
+    // Tabla de desacuerdos: clave = tupla de tokens en cada lado en
+    // esa posición. Usamos JSON.stringify para clave estable.
+    const table = new Map();
+    let freshCounter = 0;
+    const fresh = () => `?${freshCounter++}`;
+    const variables = [];
+    const outTokens = [];
+    for (let i = 0; i < len; i++) {
+        const slice = tokenized.map((t) => t[i] ?? '');
+        const allEqual = slice.every((tok) => tok === slice[0]);
+        if (allEqual) {
+            outTokens.push(slice[0] ?? '');
+            continue;
+        }
+        // Solo abstraemos posiciones identificadoras (no operadores).
+        const allIdent = slice.every((tok) => IDENT_RE.test(tok) && !RESERVED.has(tok));
+        if (!allIdent) {
+            // Desacuerdo en operador o palabra reservada → no alineable.
+            return {
+                statement: instances[0] ?? '',
+                abstractionLevel: 0,
+                nonTrivial: false,
+            };
+        }
+        const key = JSON.stringify(slice);
+        let v = table.get(key);
+        if (v === undefined) {
+            v = fresh();
+            table.set(key, v);
+            variables.push(v);
+        }
+        outTokens.push(v);
+    }
+    return {
+        statement: outTokens.join(' '),
+        abstractionLevel: variables.length,
+        nonTrivial: variables.length > 0,
+    };
+}
+/**
+ * Generaliza un grupo (lista de strings de conclusión, repetida
+ * tantas veces como instancias haya), opcionalmente capeando el
+ * abstractionLevel máximo.
+ *
+ * Si `preserveSemantic` está activo y la generalización no es
+ * instanciable de vuelta para cubrir todas las instancias, devuelve
+ * el literal de la primera instancia con abstractionLevel = 0.
+ */
+function generalizeLemma(conclusions, options) {
+    const max = options?.maxAbstractionLevel ?? 3;
+    const preserve = options?.preserveSemantic ?? true;
+    const result = generalizeFormulas(conclusions);
+    if (result.abstractionLevel > max) {
+        // Si abstrajimos demasiado, retornamos el literal.
+        return {
+            statement: conclusions[0] ?? '',
+            abstractionLevel: 0,
+            nonTrivial: false,
+        };
+    }
+    if (preserve && result.nonTrivial) {
+        // Sanity check: verificar que el pattern instanciado en cada
+        // posición produce las conclusiones originales. Por construcción
+        // del algoritmo posicional, esto siempre se cumple si todos los
+        // tokens-identificador coinciden con los slots. Hacemos chequeo
+        // explícito para defender contra cambios futuros.
+        if (!verifyPatternCoversAll(result.statement, conclusions)) {
+            return {
+                statement: conclusions[0] ?? '',
+                abstractionLevel: 0,
+                nonTrivial: false,
+            };
+        }
+    }
+    return result;
+}
+/**
+ * Verifica que el pattern (con placeholders `?0`, `?1`, …) sea
+ * instanciable para todas las conclusiones del grupo. Es un check
+ * defensivo: para el algoritmo posicional, esto siempre se cumple
+ * por construcción.
+ */
+function verifyPatternCoversAll(pattern, conclusions) {
+    const patTokens = tokenize(pattern);
+    for (const c of conclusions) {
+        const cTokens = tokenize(c);
+        if (cTokens.length !== patTokens.length)
+            return false;
+        const bindings = new Map();
+        for (let i = 0; i < patTokens.length; i++) {
+            const p = patTokens[i] ?? '';
+            const cc = cTokens[i] ?? '';
+            if (p.startsWith('?')) {
+                const prev = bindings.get(p);
+                if (prev === undefined) {
+                    bindings.set(p, cc);
+                }
+                else if (prev !== cc) {
+                    return false;
+                }
+            }
+            else if (p !== cc) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=generalizer.js.map

package/dist/reasoning/proof-mining/generalizer.js.map

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

package/dist/reasoning/proof-mining/index.d.ts

@@ -0,0 +1,62 @@
+import { TheoremCache } from '../../runtime/theorem-cache';
+import type { RankingWeights } from './ranker';
+import type { MinedLemma, MiningOptions, MiningResult, ProofTrace, UsageStats } from './types';
+export type { MinedLemma, MiningOptions, MiningResult, ProofStep, ProofTrace, UsageStats, } from './types';
+export type { SubtreeCandidate, SubtreeGroup } from './extractor';
+export type { GeneralizationResult } from './generalizer';
+export type { RankingWeights } from './ranker';
+export { extractSubtrees, groupSubtrees, subtreeKey, extractAuxiliaryLemmas, } from './extractor';
+export { generalizeLemma, generalizeFormulas, generalizeTerms, } from './generalizer';
+export { rankLemmas, scoreLemma, topK } from './ranker';
+export { persistLemmas, recoverLemmas, recoverLemmaFromCache, MINED_LEMMA_PROVER, } from './persistence';
+export { computeStats, statsToString } from './statistics';
+/**
+ * Mina lemmas del corpus de proofs. Devuelve los lemmas ordenados
+ * por score descendente + stats agregadas.
+ *
+ * Esta es la entrada principal del módulo. No persiste por defecto;
+ * para meter al cache, pasar `cache` o usar `ProofMiner`.
+ */
+export declare function mineLemmas(corpus: ProofTrace[], options?: MiningOptions & {
+    weights?: RankingWeights;
+    cache?: TheoremCache;
+}): MiningResult;
+/**
+ * `ProofMiner` es una clase fachada con estado interno: acumula
+ * lemmas a través de múltiples corpus, los persiste en un cache
+ * común, y expone consultas.
+ */
+export declare class ProofMiner {
+    private readonly cache;
+    private readonly options;
+    private readonly weights;
+    private readonly seen;
+    private totalProofsAnalyzed;
+    private totalCandidatesFound;
+    constructor(opts?: MiningOptions & {
+        weights?: RankingWeights;
+        cache?: TheoremCache;
+    });
+    /**
+     * Procesa un corpus de proofs y acumula los lemmas en estado.
+     * Lemmas con el mismo `id` se mergean: usageCount += new, savings
+     * += new, sourceProofs se unifican.
+     */
+    mine(corpus: ProofTrace[]): MiningResult;
+    /**
+     * Devuelve los lemmas acumulados, rankeados.
+     */
+    all(): MinedLemma[];
+    /**
+     * Top-k del catálogo acumulado.
+     */
+    top(k: number): MinedLemma[];
+    /**
+     * Stats agregadas.
+     */
+    stats(): UsageStats;
+    /** Cache subyacente (lectura). */
+    getCache(): TheoremCache;
+    clear(): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/reasoning/proof-mining/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/reasoning/proof-mining/index.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAY3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C,OAAO,KAAK,EACV,UAAU,EACV,aAAa,EACb,YAAY,EAEZ,UAAU,EACV,UAAU,EACX,MAAM,SAAS,CAAC;AAIjB,YAAY,EACV,UAAU,EACV,aAAa,EACb,YAAY,EACZ,SAAS,EACT,UAAU,EACV,UAAU,GACX,MAAM,SAAS,CAAC;AACjB,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAClE,YAAY,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAC1D,YAAY,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C,OAAO,EACL,eAAe,EACf,aAAa,EACb,UAAU,EACV,sBAAsB,GACvB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,eAAe,GAChB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AACxD,OAAO,EACL,aAAa,EACb,aAAa,EACb,qBAAqB,EACrB,kBAAkB,GACnB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAsF3D;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,UAAU,EAAE,EACpB,OAAO,CAAC,EAAE,aAAa,GAAG;IAAE,OAAO,CAAC,EAAE,cAAc,CAAC;IAAC,KAAK,CAAC,EAAE,YAAY,CAAA;CAAE,GAC3E,YAAY,CA0Bd;AAID;;;;GAIG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0B;IAClD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IACrD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAiC;IACtD,OAAO,CAAC,mBAAmB,CAAK;IAChC,OAAO,CAAC,oBAAoB,CAAK;gBAErB,IAAI,CAAC,EAAE,aAAa,GAAG;QAAE,OAAO,CAAC,EAAE,cAAc,CAAC;QAAC,KAAK,CAAC,EAAE,YAAY,CAAA;KAAE;IAMrF;;;;OAIG;IACH,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,YAAY;IAkCxC;;OAEG;IACH,GAAG,IAAI,UAAU,EAAE;IAInB;;OAEG;IACH,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,EAAE;IAI5B;;OAEG;IACH,KAAK,IAAI,UAAU;IAQnB,kCAAkC;IAClC,QAAQ,IAAI,YAAY;IAIxB,KAAK,IAAI,IAAI;CAKd"}

package/dist/reasoning/proof-mining/index.js

@@ -0,0 +1,235 @@
+"use strict";
+// ============================================================
+// ST Proof Mining — Barrel + orquestador
+// ============================================================
+//
+// API pública del módulo. La pipeline es:
+//
+//   mineLemmas(corpus, options)
+//     → extractor.extractAuxiliaryLemmas
+//     → para cada grupo: generalizer.generalizeLemma
+//     → ranker.rankLemmas
+//     → (opcional) persistence.persistLemmas
+//
+// `ProofMiner` es una fachada stateful que mantiene un cache
+// interno entre llamadas (útil si se procesa el corpus en batches).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProofMiner = exports.statsToString = exports.computeStats = exports.MINED_LEMMA_PROVER = exports.recoverLemmaFromCache = exports.recoverLemmas = exports.persistLemmas = exports.topK = exports.scoreLemma = exports.rankLemmas = exports.generalizeTerms = exports.generalizeFormulas = exports.generalizeLemma = exports.extractAuxiliaryLemmas = exports.subtreeKey = exports.groupSubtrees = exports.extractSubtrees = void 0;
+exports.mineLemmas = mineLemmas;
+const crypto_1 = require("crypto");
+const theorem_cache_1 = require("../../runtime/theorem-cache");
+const extractor_1 = require("./extractor");
+const generalizer_1 = require("./generalizer");
+const persistence_1 = require("./persistence");
+const ranker_1 = require("./ranker");
+const statistics_1 = require("./statistics");
+var extractor_2 = require("./extractor");
+Object.defineProperty(exports, "extractSubtrees", { enumerable: true, get: function () { return extractor_2.extractSubtrees; } });
+Object.defineProperty(exports, "groupSubtrees", { enumerable: true, get: function () { return extractor_2.groupSubtrees; } });
+Object.defineProperty(exports, "subtreeKey", { enumerable: true, get: function () { return extractor_2.subtreeKey; } });
+Object.defineProperty(exports, "extractAuxiliaryLemmas", { enumerable: true, get: function () { return extractor_2.extractAuxiliaryLemmas; } });
+var generalizer_2 = require("./generalizer");
+Object.defineProperty(exports, "generalizeLemma", { enumerable: true, get: function () { return generalizer_2.generalizeLemma; } });
+Object.defineProperty(exports, "generalizeFormulas", { enumerable: true, get: function () { return generalizer_2.generalizeFormulas; } });
+Object.defineProperty(exports, "generalizeTerms", { enumerable: true, get: function () { return generalizer_2.generalizeTerms; } });
+var ranker_2 = require("./ranker");
+Object.defineProperty(exports, "rankLemmas", { enumerable: true, get: function () { return ranker_2.rankLemmas; } });
+Object.defineProperty(exports, "scoreLemma", { enumerable: true, get: function () { return ranker_2.scoreLemma; } });
+Object.defineProperty(exports, "topK", { enumerable: true, get: function () { return ranker_2.topK; } });
+var persistence_2 = require("./persistence");
+Object.defineProperty(exports, "persistLemmas", { enumerable: true, get: function () { return persistence_2.persistLemmas; } });
+Object.defineProperty(exports, "recoverLemmas", { enumerable: true, get: function () { return persistence_2.recoverLemmas; } });
+Object.defineProperty(exports, "recoverLemmaFromCache", { enumerable: true, get: function () { return persistence_2.recoverLemmaFromCache; } });
+Object.defineProperty(exports, "MINED_LEMMA_PROVER", { enumerable: true, get: function () { return persistence_2.MINED_LEMMA_PROVER; } });
+var statistics_2 = require("./statistics");
+Object.defineProperty(exports, "computeStats", { enumerable: true, get: function () { return statistics_2.computeStats; } });
+Object.defineProperty(exports, "statsToString", { enumerable: true, get: function () { return statistics_2.statsToString; } });
+// ── Orquestador funcional ───────────────────────────────────
+function hashStatement(profile, statement) {
+    return (0, crypto_1.createHash)('sha1').update(`${profile}::${statement}`).digest('hex');
+}
+/**
+ * Construye un MinedLemma a partir de un grupo. La conclusión
+ * generalizada se obtiene del generalizer; el proof representativo
+ * es el del primer member (estructura idéntica al resto módulo
+ * renombre).
+ */
+function buildLemmaFromGroup(group, options) {
+    if (group.members.length === 0)
+        return undefined;
+    const conclusions = group.members.map((m) => m.conclusion);
+    const gen = (0, generalizer_1.generalizeLemma)(conclusions, {
+        maxAbstractionLevel: options.maxAbstractionLevel,
+        preserveSemantic: options.preserveSemantic,
+    });
+    // Stat representativo: usamos el statement generalizado si
+    // nonTrivial, si no el canonical de la primera conclusión.
+    const statement = gen.statement || group.canonicalConclusion;
+    const distinctProofs = new Set(group.members.map((m) => m.proofId));
+    const usageCount = distinctProofs.size;
+    const repMember = group.members[0];
+    if (repMember === undefined)
+        return undefined;
+    const subproofCost = repMember.cost;
+    // Saving total: cost del sub-proof × (usageCount - 1) — la 1ª
+    // ocurrencia no se ahorra, solo las subsecuentes.
+    const savings = subproofCost * Math.max(0, usageCount - 1);
+    // Re-armamos un ProofTrace independiente para el lemma. Los
+    // pasos se normalizan al subtree del primer member; las hojas
+    // (deepest steps que no tienen children) se interpretan como
+    // premises del lemma.
+    const steps = repMember.steps.map((s) => ({ ...s }));
+    // Premises: outputs de pasos cuya depth es la máxima dentro del
+    // sub-tree (hojas en el árbol).
+    let maxDepth = -1;
+    for (const s of steps)
+        if (s.depth > maxDepth)
+            maxDepth = s.depth;
+    const premises = [];
+    for (const s of steps) {
+        if (s.depth === maxDepth) {
+            // Los inputs del nivel más profundo se consideran hojas.
+            for (const inp of s.inputs) {
+                if (!premises.includes(inp))
+                    premises.push(inp);
+            }
+        }
+    }
+    const proof = {
+        conclusion: repMember.conclusion,
+        premises,
+        profile: repMember.profile,
+        steps,
+        cost: subproofCost,
+    };
+    const id = hashStatement(repMember.profile, statement);
+    return {
+        id,
+        statement,
+        proof,
+        abstractionLevel: gen.abstractionLevel,
+        usageCount,
+        savings,
+        sourceProofs: Array.from(distinctProofs).sort(),
+    };
+}
+function resolveOptions(o) {
+    return {
+        minReuseThreshold: o?.minReuseThreshold ?? 2,
+        minSubtreeSize: o?.minSubtreeSize ?? 2,
+        maxAbstractionLevel: o?.maxAbstractionLevel ?? 3,
+        preserveSemantic: o?.preserveSemantic ?? true,
+    };
+}
+/**
+ * Mina lemmas del corpus de proofs. Devuelve los lemmas ordenados
+ * por score descendente + stats agregadas.
+ *
+ * Esta es la entrada principal del módulo. No persiste por defecto;
+ * para meter al cache, pasar `cache` o usar `ProofMiner`.
+ */
+function mineLemmas(corpus, options) {
+    const opts = resolveOptions(options);
+    const groups = (0, extractor_1.extractAuxiliaryLemmas)(corpus, {
+        minReuseThreshold: opts.minReuseThreshold,
+        minSubtreeSize: opts.minSubtreeSize,
+    });
+    // Candidates count: cuántos sub-trees pasaron el primer filtro,
+    // antes del ranking final.
+    let candidatesFound = 0;
+    for (const g of groups)
+        candidatesFound += g.members.length;
+    const lemmas = [];
+    for (const g of groups) {
+        const l = buildLemmaFromGroup(g, opts);
+        if (l !== undefined)
+            lemmas.push(l);
+    }
+    const ranked = (0, ranker_1.rankLemmas)(lemmas, options?.weights);
+    const stats = (0, statistics_1.computeStats)(corpus.length, candidatesFound, ranked);
+    if (options?.cache !== undefined) {
+        (0, persistence_1.persistLemmas)(ranked, options.cache);
+    }
+    return { lemmas: ranked, stats };
+}
+// ── Fachada stateful ────────────────────────────────────────
+/**
+ * `ProofMiner` es una clase fachada con estado interno: acumula
+ * lemmas a través de múltiples corpus, los persiste en un cache
+ * común, y expone consultas.
+ */
+class ProofMiner {
+    cache;
+    options;
+    weights;
+    seen = new Map();
+    totalProofsAnalyzed = 0;
+    totalCandidatesFound = 0;
+    constructor(opts) {
+        this.options = resolveOptions(opts);
+        this.weights = opts?.weights;
+        this.cache = opts?.cache ?? new theorem_cache_1.TheoremCache();
+    }
+    /**
+     * Procesa un corpus de proofs y acumula los lemmas en estado.
+     * Lemmas con el mismo `id` se mergean: usageCount += new, savings
+     * += new, sourceProofs se unifican.
+     */
+    mine(corpus) {
+        const single = mineLemmas(corpus, {
+            ...this.options,
+            weights: this.weights,
+        });
+        this.totalProofsAnalyzed += corpus.length;
+        this.totalCandidatesFound += single.stats.candidatesFound;
+        for (const l of single.lemmas) {
+            const existing = this.seen.get(l.id);
+            if (existing === undefined) {
+                this.seen.set(l.id, l);
+                continue;
+            }
+            // Merge: unión de sourceProofs y suma de usage/savings.
+            const merged = {
+                ...existing,
+                usageCount: existing.usageCount + l.usageCount,
+                savings: existing.savings + l.savings,
+                sourceProofs: Array.from(new Set([...existing.sourceProofs, ...l.sourceProofs])).sort(),
+            };
+            this.seen.set(l.id, merged);
+        }
+        // Persistir lo nuevo en el cache.
+        (0, persistence_1.persistLemmas)(Array.from(this.seen.values()), this.cache);
+        const all = (0, ranker_1.rankLemmas)(Array.from(this.seen.values()), this.weights);
+        const stats = (0, statistics_1.computeStats)(this.totalProofsAnalyzed, this.totalCandidatesFound, all);
+        return { lemmas: all, stats };
+    }
+    /**
+     * Devuelve los lemmas acumulados, rankeados.
+     */
+    all() {
+        return (0, ranker_1.rankLemmas)(Array.from(this.seen.values()), this.weights);
+    }
+    /**
+     * Top-k del catálogo acumulado.
+     */
+    top(k) {
+        return (0, ranker_1.topK)(Array.from(this.seen.values()), k, this.weights);
+    }
+    /**
+     * Stats agregadas.
+     */
+    stats() {
+        return (0, statistics_1.computeStats)(this.totalProofsAnalyzed, this.totalCandidatesFound, Array.from(this.seen.values()));
+    }
+    /** Cache subyacente (lectura). */
+    getCache() {
+        return this.cache;
+    }
+    clear() {
+        this.seen.clear();
+        this.totalProofsAnalyzed = 0;
+        this.totalCandidatesFound = 0;
+    }
+}
+exports.ProofMiner = ProofMiner;
+//# sourceMappingURL=index.js.map

package/dist/reasoning/proof-mining/index.js.map

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

package/dist/reasoning/proof-mining/persistence.d.ts

@@ -0,0 +1,35 @@
+import { TheoremCache, type CachedTheorem } from '../../runtime/theorem-cache';
+import type { MinedLemma } from './types';
+/**
+ * Marca metadata.provedBy que identifica un lemma como minado.
+ */
+export declare const MINED_LEMMA_PROVER = "proof-mining";
+/**
+ * Guarda una lista de lemmas minados en el cache. Devuelve los ids
+ * (post-hash del cache, que puede diferir si el cache normaliza la
+ * fórmula de forma distinta).
+ *
+ * `now` es inyectable para tests deterministas (default `Date.now()`).
+ */
+export declare function persistLemmas(lemmas: MinedLemma[], cache: TheoremCache, now?: () => number): string[];
+/**
+ * Reconstruye un MinedLemma desde una entry cacheada (best-effort).
+ * Si la entry no fue persistida vía `persistLemmas`, devuelve
+ * `undefined`.
+ */
+export declare function recoverLemmaFromCache(theorem: CachedTheorem): MinedLemma | undefined;
+/**
+ * Recupera lemmas minados desde el cache a partir de una lista de
+ * statements canónicos esperados. Para cada `(statement, profile)`
+ * que efectivamente esté cacheado por `persistLemmas`, devuelve el
+ * MinedLemma reconstruido.
+ *
+ * Esta API existe porque `TheoremCache` no expone iteración total
+ * por design (LRU + persistencia). El caller que persistió los
+ * lemmas conoce sus statements; los pasa aquí para recuperarlos.
+ */
+export declare function recoverLemmas(cache: TheoremCache, entries: Array<{
+    statement: string;
+    profile: string;
+}>): MinedLemma[];
+//# sourceMappingURL=persistence.d.ts.map

package/dist/reasoning/proof-mining/persistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence.d.ts","sourceRoot":"","sources":["../../../src/reasoning/proof-mining/persistence.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAE,YAAY,EAAE,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC/E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C;;GAEG;AACH,eAAO,MAAM,kBAAkB,iBAAiB,CAAC;AAEjD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,UAAU,EAAE,EACpB,KAAK,EAAE,YAAY,EACnB,GAAG,GAAE,MAAM,MAAiB,GAC3B,MAAM,EAAE,CA4BV;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,aAAa,GAAG,UAAU,GAAG,SAAS,CAwCpF;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,KAAK,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,GACrD,UAAU,EAAE,CASd"}