@stevenvo780/st-lang 4.14.1 → 4.15.0

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"}

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

@@ -0,0 +1,126 @@
+"use strict";
+// ============================================================
+// ST Proof Mining — Persistencia en theorem-cache
+// ============================================================
+//
+// Bridge entre los MinedLemma y el TheoremCache existente. La idea:
+// los lemmas extraídos viven con primera clase en el cache, igual
+// que cualquier teorema probado, y se benefician del α-canonical
+// hashing + LRU + persistencia a disco.
+//
+// El mapping es directo:
+//
+//   MinedLemma.id        ← TheoremCache id (recalculado)
+//   MinedLemma.statement → CachedTheorem.formula
+//   MinedLemma.proof     → CachedTheorem.proof (estructura completa)
+//   profile              → CachedTheorem.profile
+//   metadata.provedBy    = 'proof-mining'
+//   metadata.ms          = subproof.cost
+//
+// `persistLemmas(lemmas, cache)` guarda. `recoverLemmas(cache,
+// profile)` recupera todos los mined-lemmas de ese profile.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MINED_LEMMA_PROVER = void 0;
+exports.persistLemmas = persistLemmas;
+exports.recoverLemmaFromCache = recoverLemmaFromCache;
+exports.recoverLemmas = recoverLemmas;
+/**
+ * Marca metadata.provedBy que identifica un lemma como minado.
+ */
+exports.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()`).
+ */
+function persistLemmas(lemmas, cache, now = Date.now) {
+    const ids = [];
+    for (const l of lemmas) {
+        const cached = {
+            formula: l.statement,
+            normalizedFormula: cache.canonicalize(l.statement),
+            profile: l.proof.profile,
+            proof: {
+                // Estructura del proof completo, sin perder metadata de mining.
+                steps: l.proof.steps,
+                conclusion: l.proof.conclusion,
+                premises: l.proof.premises,
+                abstractionLevel: l.abstractionLevel,
+                usageCount: l.usageCount,
+                savings: l.savings,
+                sourceProofs: l.sourceProofs,
+            },
+            verifier: undefined,
+            metadata: {
+                provedAt: new Date(now()).toISOString(),
+                ms: Math.round(l.proof.cost),
+                provedBy: exports.MINED_LEMMA_PROVER,
+            },
+        };
+        const id = cache.store(cached);
+        ids.push(id);
+    }
+    return ids;
+}
+/**
+ * Reconstruye un MinedLemma desde una entry cacheada (best-effort).
+ * Si la entry no fue persistida vía `persistLemmas`, devuelve
+ * `undefined`.
+ */
+function recoverLemmaFromCache(theorem) {
+    if (theorem.metadata.provedBy !== exports.MINED_LEMMA_PROVER)
+        return undefined;
+    const proof = theorem.proof;
+    if (!proof ||
+        typeof proof !== 'object' ||
+        !Array.isArray(proof.steps) ||
+        typeof proof.conclusion !== 'string' ||
+        !Array.isArray(proof.premises) ||
+        typeof proof.abstractionLevel !== 'number' ||
+        typeof proof.usageCount !== 'number' ||
+        typeof proof.savings !== 'number' ||
+        !Array.isArray(proof.sourceProofs)) {
+        return undefined;
+    }
+    return {
+        id: theorem.id,
+        statement: theorem.formula,
+        proof: {
+            id: theorem.id,
+            conclusion: proof.conclusion,
+            premises: proof.premises,
+            profile: theorem.profile,
+            steps: proof.steps,
+            cost: theorem.metadata.ms,
+        },
+        abstractionLevel: proof.abstractionLevel,
+        usageCount: proof.usageCount,
+        savings: proof.savings,
+        sourceProofs: proof.sourceProofs,
+    };
+}
+/**
+ * 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.
+ */
+function recoverLemmas(cache, entries) {
+    const out = [];
+    for (const e of entries) {
+        const th = cache.retrieve(e.statement, e.profile);
+        if (th === undefined)
+            continue;
+        const recovered = recoverLemmaFromCache(th);
+        if (recovered !== undefined)
+            out.push(recovered);
+    }
+    return out;
+}
+//# sourceMappingURL=persistence.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"persistence.js","sourceRoot":"","sources":["../../../src/reasoning/proof-mining/persistence.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,kDAAkD;AAClD,+DAA+D;AAC/D,EAAE;AACF,oEAAoE;AACpE,kEAAkE;AAClE,iEAAiE;AACjE,wCAAwC;AACxC,EAAE;AACF,yBAAyB;AACzB,EAAE;AACF,yDAAyD;AACzD,iDAAiD;AACjD,qEAAqE;AACrE,iDAAiD;AACjD,0CAA0C;AAC1C,yCAAyC;AACzC,EAAE;AACF,+DAA+D;AAC/D,4DAA4D;;;AAiB5D,sCAgCC;AAOD,sDAwCC;AAYD,sCAYC;AAnHD;;GAEG;AACU,QAAA,kBAAkB,GAAG,cAAc,CAAC;AAEjD;;;;;;GAMG;AACH,SAAgB,aAAa,CAC3B,MAAoB,EACpB,KAAmB,EACnB,MAAoB,IAAI,CAAC,GAAG;IAE5B,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;QACvB,MAAM,MAAM,GAA8B;YACxC,OAAO,EAAE,CAAC,CAAC,SAAS;YACpB,iBAAiB,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS,CAAC;YAClD,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO;YACxB,KAAK,EAAE;gBACL,gEAAgE;gBAChE,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK;gBACpB,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,UAAU;gBAC9B,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,QAAQ;gBAC1B,gBAAgB,EAAE,CAAC,CAAC,gBAAgB;gBACpC,UAAU,EAAE,CAAC,CAAC,UAAU;gBACxB,OAAO,EAAE,CAAC,CAAC,OAAO;gBAClB,YAAY,EAAE,CAAC,CAAC,YAAY;aAC7B;YACD,QAAQ,EAAE,SAAS;YACnB,QAAQ,EAAE;gBACR,QAAQ,EAAE,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,WAAW,EAAE;gBACvC,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC;gBAC5B,QAAQ,EAAE,0BAAkB;aAC7B;SACF,CAAC;QACF,MAAM,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAC/B,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACf,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;GAIG;AACH,SAAgB,qBAAqB,CAAC,OAAsB;IAC1D,IAAI,OAAO,CAAC,QAAQ,CAAC,QAAQ,KAAK,0BAAkB;QAAE,OAAO,SAAS,CAAC;IACvE,MAAM,KAAK,GAAG,OAAO,CAAC,KAQrB,CAAC;IACF,IACE,CAAC,KAAK;QACN,OAAO,KAAK,KAAK,QAAQ;QACzB,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC;QAC3B,OAAO,KAAK,CAAC,UAAU,KAAK,QAAQ;QACpC,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC;QAC9B,OAAO,KAAK,CAAC,gBAAgB,KAAK,QAAQ;QAC1C,OAAO,KAAK,CAAC,UAAU,KAAK,QAAQ;QACpC,OAAO,KAAK,CAAC,OAAO,KAAK,QAAQ;QACjC,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,EAClC,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO;QACL,EAAE,EAAE,OAAO,CAAC,EAAE;QACd,SAAS,EAAE,OAAO,CAAC,OAAO;QAC1B,KAAK,EAAE;YACL,EAAE,EAAE,OAAO,CAAC,EAAE;YACd,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,QAAQ,EAAE,KAAK,CAAC,QAAoB;YACpC,OAAO,EAAE,OAAO,CAAC,OAAO;YACxB,KAAK,EAAE,KAAK,CAAC,KAAqC;YAClD,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE;SAC1B;QACD,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;QACxC,UAAU,EAAE,KAAK,CAAC,UAAU;QAC5B,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,YAAY,EAAE,KAAK,CAAC,YAAwB;KAC7C,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,aAAa,CAC3B,KAAmB,EACnB,OAAsD;IAEtD,MAAM,GAAG,GAAiB,EAAE,CAAC;IAC7B,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;QACxB,MAAM,EAAE,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC;QAClD,IAAI,EAAE,KAAK,SAAS;YAAE,SAAS;QAC/B,MAAM,SAAS,GAAG,qBAAqB,CAAC,EAAE,CAAC,CAAC;QAC5C,IAAI,SAAS,KAAK,SAAS;YAAE,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACnD,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

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

@@ -0,0 +1,29 @@
+import type { MinedLemma } from './types';
+export interface RankingWeights {
+    /** Peso del saving total. Default 0.5. */
+    savings?: number;
+    /** Peso del usage count (normalizado log). Default 0.3. */
+    usage?: number;
+    /** Peso del abstraction level. Default 0.2. */
+    generality?: number;
+}
+/**
+ * Score numérico de un lemma según los pesos. Mayor = mejor.
+ *
+ * Normalizaciones:
+ *   - savings: log(1 + savings)
+ *   - usage:   log(1 + usageCount)
+ *   - generality: abstractionLevel (raw)
+ */
+export declare function scoreLemma(lemma: MinedLemma, weights?: RankingWeights): number;
+/**
+ * Ordena los lemmas de mayor a menor score. NO muta el array
+ * original. En empates: usageCount desc, luego id asc para
+ * determinismo.
+ */
+export declare function rankLemmas(lemmas: MinedLemma[], weights?: RankingWeights): MinedLemma[];
+/**
+ * Filtra los top-K lemmas por score.
+ */
+export declare function topK(lemmas: MinedLemma[], k: number, weights?: RankingWeights): MinedLemma[];
+//# sourceMappingURL=ranker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ranker.d.ts","sourceRoot":"","sources":["../../../src/reasoning/proof-mining/ranker.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C,MAAM,WAAW,cAAc;IAC7B,0CAA0C;IAC1C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,+CAA+C;IAC/C,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAgBD;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,CAM9E;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,UAAU,EAAE,CASvF;AAED;;GAEG;AACH,wBAAgB,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,UAAU,EAAE,CAE5F"}

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

@@ -0,0 +1,71 @@
+"use strict";
+// ============================================================
+// ST Proof Mining — Ranking de lemmas extraídos
+// ============================================================
+//
+// Score de un lemma = combinación lineal de:
+//   - usefulness  : usageCount (cuánto se reusa)
+//   - savings     : sum(cost) ahorrado por reusos
+//   - generality  : abstractionLevel (cuán abstracto es)
+//
+// Default weights privilegian savings (impacto directo en tiempo),
+// luego frecuencia (señal de reuso real), luego generalidad
+// (un lemma muy abstracto es valioso aunque su saving inmediato
+// sea bajo, porque admite más instancias).
+//
+// El caller puede sobreescribir pesos para experimentar.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scoreLemma = scoreLemma;
+exports.rankLemmas = rankLemmas;
+exports.topK = topK;
+const DEFAULT_WEIGHTS = {
+    savings: 0.5,
+    usage: 0.3,
+    generality: 0.2,
+};
+function resolveWeights(w) {
+    return {
+        savings: w?.savings ?? DEFAULT_WEIGHTS.savings,
+        usage: w?.usage ?? DEFAULT_WEIGHTS.usage,
+        generality: w?.generality ?? DEFAULT_WEIGHTS.generality,
+    };
+}
+/**
+ * Score numérico de un lemma según los pesos. Mayor = mejor.
+ *
+ * Normalizaciones:
+ *   - savings: log(1 + savings)
+ *   - usage:   log(1 + usageCount)
+ *   - generality: abstractionLevel (raw)
+ */
+function scoreLemma(lemma, weights) {
+    const w = resolveWeights(weights);
+    const sv = Math.log1p(Math.max(0, lemma.savings));
+    const uc = Math.log1p(Math.max(0, lemma.usageCount));
+    const ab = Math.max(0, lemma.abstractionLevel);
+    return w.savings * sv + w.usage * uc + w.generality * ab;
+}
+/**
+ * Ordena los lemmas de mayor a menor score. NO muta el array
+ * original. En empates: usageCount desc, luego id asc para
+ * determinismo.
+ */
+function rankLemmas(lemmas, weights) {
+    const w = resolveWeights(weights);
+    const decorated = lemmas.map((l) => ({ l, s: scoreLemma(l, w) }));
+    decorated.sort((a, b) => {
+        if (b.s !== a.s)
+            return b.s - a.s;
+        if (b.l.usageCount !== a.l.usageCount)
+            return b.l.usageCount - a.l.usageCount;
+        return a.l.id.localeCompare(b.l.id);
+    });
+    return decorated.map((d) => d.l);
+}
+/**
+ * Filtra los top-K lemmas por score.
+ */
+function topK(lemmas, k, weights) {
+    return rankLemmas(lemmas, weights).slice(0, Math.max(0, k));
+}
+//# sourceMappingURL=ranker.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ranker.js","sourceRoot":"","sources":["../../../src/reasoning/proof-mining/ranker.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,gDAAgD;AAChD,+DAA+D;AAC/D,EAAE;AACF,6CAA6C;AAC7C,iDAAiD;AACjD,kDAAkD;AAClD,yDAAyD;AACzD,EAAE;AACF,mEAAmE;AACnE,4DAA4D;AAC5D,gEAAgE;AAChE,2CAA2C;AAC3C,EAAE;AACF,yDAAyD;;AAmCzD,gCAMC;AAOD,gCASC;AAKD,oBAEC;AAnDD,MAAM,eAAe,GAA6B;IAChD,OAAO,EAAE,GAAG;IACZ,KAAK,EAAE,GAAG;IACV,UAAU,EAAE,GAAG;CAChB,CAAC;AAEF,SAAS,cAAc,CAAC,CAAkB;IACxC,OAAO;QACL,OAAO,EAAE,CAAC,EAAE,OAAO,IAAI,eAAe,CAAC,OAAO;QAC9C,KAAK,EAAE,CAAC,EAAE,KAAK,IAAI,eAAe,CAAC,KAAK;QACxC,UAAU,EAAE,CAAC,EAAE,UAAU,IAAI,eAAe,CAAC,UAAU;KACxD,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,UAAU,CAAC,KAAiB,EAAE,OAAwB;IACpE,MAAM,CAAC,GAAG,cAAc,CAAC,OAAO,CAAC,CAAC;IAClC,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;IAClD,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;IACrD,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC;IAC/C,OAAO,CAAC,CAAC,OAAO,GAAG,EAAE,GAAG,CAAC,CAAC,KAAK,GAAG,EAAE,GAAG,CAAC,CAAC,UAAU,GAAG,EAAE,CAAC;AAC3D,CAAC;AAED;;;;GAIG;AACH,SAAgB,UAAU,CAAC,MAAoB,EAAE,OAAwB;IACvE,MAAM,CAAC,GAAG,cAAc,CAAC,OAAO,CAAC,CAAC;IAClC,MAAM,SAAS,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAClE,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;QACtB,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;YAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAClC,IAAI,CAAC,CAAC,CAAC,CAAC,UAAU,KAAK,CAAC,CAAC,CAAC,CAAC,UAAU;YAAE,OAAO,CAAC,CAAC,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC;QAC9E,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IACtC,CAAC,CAAC,CAAC;IACH,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACnC,CAAC;AAED;;GAEG;AACH,SAAgB,IAAI,CAAC,MAAoB,EAAE,CAAS,EAAE,OAAwB;IAC5E,OAAO,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAC9D,CAAC"}

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

@@ -0,0 +1,11 @@
+import type { MinedLemma, UsageStats } from './types';
+/**
+ * Computa las stats agregadas dado el corpus original y la lista
+ * final de lemmas extraídos.
+ */
+export declare function computeStats(proofsAnalyzed: number, candidatesFound: number, lemmas: MinedLemma[]): UsageStats;
+/**
+ * Render textual de las stats (para logs / debugging).
+ */
+export declare function statsToString(s: UsageStats): string;
+//# sourceMappingURL=statistics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"statistics.d.ts","sourceRoot":"","sources":["../../../src/reasoning/proof-mining/statistics.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAEtD;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,MAAM,EACvB,MAAM,EAAE,UAAU,EAAE,GACnB,UAAU,CAiBZ;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,CASnD"}

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

@@ -0,0 +1,44 @@
+"use strict";
+// ============================================================
+// ST Proof Mining — Estadísticas
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeStats = computeStats;
+exports.statsToString = statsToString;
+/**
+ * Computa las stats agregadas dado el corpus original y la lista
+ * final de lemmas extraídos.
+ */
+function computeStats(proofsAnalyzed, candidatesFound, lemmas) {
+    let totalSavings = 0;
+    let totalUsage = 0;
+    let generalizedCount = 0;
+    for (const l of lemmas) {
+        totalSavings += l.savings;
+        totalUsage += l.usageCount;
+        if (l.abstractionLevel > 0)
+            generalizedCount++;
+    }
+    return {
+        proofsAnalyzed,
+        candidatesFound,
+        lemmasExtracted: lemmas.length,
+        totalSavings,
+        averageUsage: lemmas.length === 0 ? 0 : totalUsage / lemmas.length,
+        generalizedCount,
+    };
+}
+/**
+ * Render textual de las stats (para logs / debugging).
+ */
+function statsToString(s) {
+    return [
+        `proofsAnalyzed=${s.proofsAnalyzed}`,
+        `candidates=${s.candidatesFound}`,
+        `extracted=${s.lemmasExtracted}`,
+        `totalSavings=${s.totalSavings.toFixed(2)}`,
+        `avgUsage=${s.averageUsage.toFixed(2)}`,
+        `generalized=${s.generalizedCount}`,
+    ].join(' ');
+}
+//# sourceMappingURL=statistics.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"statistics.js","sourceRoot":"","sources":["../../../src/reasoning/proof-mining/statistics.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,iCAAiC;AACjC,+DAA+D;;AAQ/D,oCAqBC;AAKD,sCASC;AAvCD;;;GAGG;AACH,SAAgB,YAAY,CAC1B,cAAsB,EACtB,eAAuB,EACvB,MAAoB;IAEpB,IAAI,YAAY,GAAG,CAAC,CAAC;IACrB,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,IAAI,gBAAgB,GAAG,CAAC,CAAC;IACzB,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;QACvB,YAAY,IAAI,CAAC,CAAC,OAAO,CAAC;QAC1B,UAAU,IAAI,CAAC,CAAC,UAAU,CAAC;QAC3B,IAAI,CAAC,CAAC,gBAAgB,GAAG,CAAC;YAAE,gBAAgB,EAAE,CAAC;IACjD,CAAC;IACD,OAAO;QACL,cAAc;QACd,eAAe;QACf,eAAe,EAAE,MAAM,CAAC,MAAM;QAC9B,YAAY;QACZ,YAAY,EAAE,MAAM,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,GAAG,MAAM,CAAC,MAAM;QAClE,gBAAgB;KACjB,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAgB,aAAa,CAAC,CAAa;IACzC,OAAO;QACL,kBAAkB,CAAC,CAAC,cAAc,EAAE;QACpC,cAAc,CAAC,CAAC,eAAe,EAAE;QACjC,aAAa,CAAC,CAAC,eAAe,EAAE;QAChC,gBAAgB,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;QAC3C,YAAY,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;QACvC,eAAe,CAAC,CAAC,gBAAgB,EAAE;KACpC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACd,CAAC"}