@stevenvo780/st-lang 4.14.0 → 4.15.0

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

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

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

@@ -0,0 +1,117 @@
+/**
+ * Un paso individual de una proof trace. `rule` es el nombre de la
+ * regla de inferencia (MP, ∧I, cut, etc.) y `inputs` son los outputs
+ * de pasos previos consumidos. `output` es la fórmula derivada.
+ *
+ * `depth` permite reconstruir el árbol sin tener que cargar punteros:
+ * el paso 0 es la conclusión, los pasos con depth+1 son sus hijos
+ * inmediatos. Esto se usa internamente para subtree matching.
+ */
+export interface ProofStep {
+    /** Nombre de la regla de inferencia usada. */
+    rule: string;
+    /** Fórmulas (outputs de pasos previos) consumidas por la regla. */
+    inputs: string[];
+    /** Fórmula derivada por este paso. */
+    output: string;
+    /** Profundidad en el árbol de prueba (0 = conclusión final). */
+    depth: number;
+}
+/**
+ * Traza de una prueba ya derivada. Es la unidad de entrada del
+ * miner. La conclusión es la fórmula final; las premisas son las
+ * hojas (axiomas, hipótesis). `steps` está en orden top-down: el
+ * primer paso es la conclusión, los siguientes profundizan.
+ *
+ * `cost` es heurístico: longitud de la prueba, depth × branching o
+ * tiempo wall-clock. El caller decide. Si la sub-prueba extraída
+ * tiene cost K y aparece N veces, el saving total es K·(N-1).
+ */
+export interface ProofTrace {
+    /** Identificador opcional de la prueba (e.g. hash original). */
+    id?: string;
+    /** Fórmula conclusión. */
+    conclusion: string;
+    /** Hojas: axiomas / hipótesis. */
+    premises: string[];
+    /** Slug del perfil lógico (clásico, intuicionista, etc.). */
+    profile: string;
+    /** Pasos del árbol, top-down con `depth`. */
+    steps: ProofStep[];
+    /** Cost heurístico (longitud, depth × branching, ms, etc.). */
+    cost: number;
+}
+/**
+ * Un lemma extraído del corpus.
+ *
+ * - `id` es el hash α-canónico (compatible con TheoremCache).
+ * - `statement` es la conclusión del sub-tree (posiblemente
+ *   generalizada por anti-unification).
+ * - `abstractionLevel` indica cuántas variables fresh introdujo la
+ *   generalización (0 = literal, n = n-level abstraction).
+ * - `usageCount` es la cantidad de proofs donde el lemma calza.
+ * - `savings` es la suma de `cost` que se evita al reusar el lemma:
+ *   cost_subproof × (usageCount − 1).
+ * - `sourceProofs` enumera las trazas donde se encontró el match.
+ */
+export interface MinedLemma {
+    id: string;
+    statement: string;
+    proof: ProofTrace;
+    abstractionLevel: number;
+    usageCount: number;
+    savings: number;
+    sourceProofs: string[];
+}
+/**
+ * Opciones de minería.
+ */
+export interface MiningOptions {
+    /**
+     * Umbral mínimo de reutilización para extraer un sub-tree como
+     * lemma. Default 2 (debe aparecer al menos en 2 proofs).
+     */
+    minReuseThreshold?: number;
+    /**
+     * Tamaño mínimo del sub-tree (cantidad de pasos) para ser candidato
+     * a lemma. Sub-trees de 1 paso son triviales y se descartan.
+     * Default 2.
+     */
+    minSubtreeSize?: number;
+    /**
+     * Nivel máximo de generalización. La anti-unificación se aplica
+     * iterativamente; cap de seguridad. Default 3.
+     */
+    maxAbstractionLevel?: number;
+    /**
+     * Si `true`, la generalización debe preservar la propiedad de
+     * que toda instancia del pattern sea una prueba válida (verificado
+     * sobre el corpus original). Default `true`.
+     */
+    preserveSemantic?: boolean;
+}
+/**
+ * Estadísticas agregadas del proceso de minería.
+ */
+export interface UsageStats {
+    /** Cantidad de proofs procesadas. */
+    proofsAnalyzed: number;
+    /** Sub-trees candidatos encontrados (antes de filtrado). */
+    candidatesFound: number;
+    /** Lemmas finalmente extraídos (post-filtrado y ranking). */
+    lemmasExtracted: number;
+    /** Sumatoria de savings de todos los lemmas. */
+    totalSavings: number;
+    /** Promedio de usageCount por lemma. */
+    averageUsage: number;
+    /** Cantidad de lemmas que pasaron por generalization. */
+    generalizedCount: number;
+}
+/**
+ * Resultado completo de una corrida de mining.
+ */
+export interface MiningResult {
+    lemmas: MinedLemma[];
+    stats: UsageStats;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/reasoning/proof-mining/types.ts"],"names":[],"mappings":"AAsBA;;;;;;;;GAQG;AACH,MAAM,WAAW,SAAS;IACxB,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,mEAAmE;IACnE,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,UAAU;IACzB,gEAAgE;IAChE,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,0BAA0B;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,kCAAkC;IAClC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,6DAA6D;IAC7D,OAAO,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,+DAA+D;IAC/D,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,UAAU,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,qCAAqC;IACrC,cAAc,EAAE,MAAM,CAAC;IACvB,4DAA4D;IAC5D,eAAe,EAAE,MAAM,CAAC;IACxB,6DAA6D;IAC7D,eAAe,EAAE,MAAM,CAAC;IACxB,gDAAgD;IAChD,YAAY,EAAE,MAAM,CAAC;IACrB,wCAAwC;IACxC,YAAY,EAAE,MAAM,CAAC;IACrB,yDAAyD;IACzD,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,UAAU,EAAE,CAAC;IACrB,KAAK,EAAE,UAAU,CAAC;CACnB"}

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

@@ -0,0 +1,24 @@
+"use strict";
+// ============================================================
+// ST Proof Mining — Tipos públicos
+// ============================================================
+//
+// Proof mining (a.k.a. lemma extraction) toma un corpus de pruebas
+// ya derivadas y extrae sub-pruebas reutilizables como lemmas
+// independientes. La idea: si la misma estructura aparece en 2+
+// pruebas, conviene cachearla con su propia entry para que futuras
+// derivaciones la reusen sin re-trabajar.
+//
+// Diferencia con `lemma-synthesis`:
+//   - lemma-synthesis ENUMERA conjeturas a partir de una signatura
+//     y un evaluador (theory exploration estilo QuickSpec).
+//   - proof-mining EXTRAE lemmas de pruebas que ya existen
+//     (bottom-up desde el corpus, sin enumeración).
+//
+// Pipeline:
+//   1. extract: encontrar sub-trees comunes entre pruebas.
+//   2. generalize: anti-unify para subir el nivel de abstracción.
+//   3. rank: ordenar por usefulness (savings · frecuencia · generalidad).
+//   4. persist: meter en TheoremCache con hash α-canónico.
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/reasoning/proof-mining/types.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,mCAAmC;AACnC,+DAA+D;AAC/D,EAAE;AACF,mEAAmE;AACnE,8DAA8D;AAC9D,gEAAgE;AAChE,mEAAmE;AACnE,0CAA0C;AAC1C,EAAE;AACF,oCAAoC;AACpC,mEAAmE;AACnE,4DAA4D;AAC5D,2DAA2D;AAC3D,oDAAoD;AACpD,EAAE;AACF,YAAY;AACZ,2DAA2D;AAC3D,kEAAkE;AAClE,0EAA0E;AAC1E,2DAA2D"}

package/dist/reasoning/separation-logic/index.d.ts

@@ -1,3 +1,4 @@
+/** Valor que puede almacenarse en el heap de separación: entero, dirección o null. */
 export type SLValue = {
     kind: 'int';
     value: number;
@@ -7,15 +8,20 @@ export type SLValue = {
 } | {
     kind: 'null';
 };
+/** Constructor de valor entero del heap de separación. */
 export declare function intVal(value: number): SLValue;
+/** Constructor de valor dirección del heap de separación. */
 export declare function addrVal(loc: number): SLValue;
+/** Singleton null del heap de separación (puntero nulo). */
 export declare function nullVal(): SLValue;
+/** Igualdad estructural entre dos valores del heap de separación. */
 export declare function valueEquals(a: SLValue, b: SLValue): boolean;
 /** Convierte un SLValue a una clave string estable para Maps. */
 export declare function valueKey(v: SLValue): string;
 /** Devuelve la dirección de un SLValue si es addr, o null en cualquier
  * otro caso. La null-location no se direcciona. */
 export declare function asLoc(v: SLValue): number | null;
+/** Heap finito de separación: mapa inmutable de direcciones (number) a valores SL. */
 export interface Heap {
     readonly map: ReadonlyMap<number, SLValue>;
     domain(): number[];
@@ -26,7 +32,9 @@ export interface Heap {
     size(): number;
     clone(): Heap;
 }
+/** Crea un heap vacío. */
 export declare function newHeap(): Heap;
+/** Crea un heap a partir de una lista de pares `[dirección, valor]`. */
 export declare function fromMap(entries: Array<[number, SLValue]>): Heap;
 /** Dos heaps son disjuntos sii sus dominios no se intersectan. */
 export declare function disjoint(h1: Heap, h2: Heap): boolean;
@@ -40,6 +48,7 @@ export declare function splits(h: Heap): Array<{
     h1: Heap;
     h2: Heap;
 }>;
+/** Fórmula de separación lógica (SL). Cubre emp, pointsTo, star (*), magic wand (-*), cuantificadores y lógica proposicional pura. */
 export type SLFormula = {
     kind: 'emp';
 } | {
@@ -82,20 +91,35 @@ export type SLFormula = {
     bind: string;
     body: SLFormula;
 };
+/** Predicado puro de SL: función JavaScript que evalúa una condición sobre la valuación de variables. */
 export type PurePredicate = (val: SLValuation) => boolean;
+/** Heap vacío: `emp`. La fórmula que vale sobre el heap vacío. */
 export declare const emp: () => SLFormula;
+/** `loc ↦ val` — `loc` apunta a `val` (heap de un solo celda). */
 export declare const pointsTo: (loc: SLValue, val: SLValue) => SLFormula;
+/** Conjunción separante `P * Q`: `P` y `Q` valen sobre sub-heaps disjuntos cuya unión es el heap total. */
 export declare const star: (left: SLFormula, right: SLFormula) => SLFormula;
+/** Magic wand `P -* Q`: para cualquier heap disjunto que satisfaga `P`, la unión satisface `Q`. */
 export declare const magicWand: (left: SLFormula, right: SLFormula) => SLFormula;
+/** Fórmula pura `[expr]`: condición sin acceso al heap, evaluada por `predicate`. */
 export declare const pure: (expression: string, predicate: PurePredicate) => SLFormula;
+/** Conjunción clásica de dos fórmulas SL (no separante). */
 export declare const andF: (left: SLFormula, right: SLFormula) => SLFormula;
+/** Disyunción de dos fórmulas SL. */
 export declare const orF: (left: SLFormula, right: SLFormula) => SLFormula;
+/** Implicación clásica entre dos fórmulas SL. */
 export declare const impliesF: (left: SLFormula, right: SLFormula) => SLFormula;
+/** Negación de una fórmula SL. */
 export declare const notF: (body: SLFormula) => SLFormula;
+/** Cuantificador existencial sobre una variable de valuación. */
 export declare const existsF: (bind: string, body: SLFormula) => SLFormula;
+/** Cuantificador universal sobre una variable de valuación. */
 export declare const forallF: (bind: string, body: SLFormula) => SLFormula;
+/** Serializa una fórmula SL a su representación textual estándar. */
 export declare function formulaToString(f: SLFormula): string;
+/** Serializa un valor SL (int, addr, null) a texto legible. */
 export declare function valueToString(v: SLValue): string;
+/** Mapa de variables de SL a valores; permite atar variables lógicas durante la evaluación. */
 export interface SLValuation {
     [varName: string]: SLValue;
 }
@@ -103,6 +127,7 @@ export interface SLValuation {
 export declare function bind(val: SLValuation, name: string, v: SLValue): SLValuation;
 /** `satisfies(P, h, ν)` — el modelo `(h, ν)` satisface la fórmula P. */
 export declare function satisfies(formula: SLFormula, heap: Heap, val: SLValuation): boolean;
+/** Comando de SL: operación de heap que puede modificar el heap y/o la valuación de variables. */
 export interface SLCommand {
     kind: 'alloc' | 'free' | 'load' | 'store' | 'skip' | 'assign';
     /** Variable destino para `alloc`/`load`/`assign`. */
@@ -112,6 +137,7 @@ export interface SLCommand {
     /** Valor a almacenar (para `alloc`, `store`, `assign`). */
     value?: SLValue;
 }
+/** Tripla de Hoare para SL: `{ pre } cmd { post }`. */
 export interface SLTriple {
     pre: SLFormula;
     cmd: SLCommand;
@@ -128,6 +154,7 @@ export interface ExecResult {
 }
 /** Ejecuta un único comando de forma small-step. */
 export declare function executeCommand(cmd: SLCommand, heap: Heap, val: SLValuation): ExecResult;
+/** Opciones para `checkTriple`: heaps candidatos, tamaño de muestreo y semilla RNG. */
 export interface CheckTripleOptions {
     /** Heaps candidatos a probar como precondición. Si no se da, se generan. */
     candidates?: Array<{
@@ -139,6 +166,7 @@ export interface CheckTripleOptions {
     /** Semilla para el RNG (LCG simple) — reproducibilidad. */
     seed?: number;
 }
+/** Resultado de `checkTriple`: validez (o contraejemplo encontrado) y cantidad de modelos evaluados. */
 export interface CheckTripleResult {
     valid: boolean;
     counterexample?: {
@@ -174,11 +202,13 @@ export declare function satisfiesShape(formula: SLFormula, heap: Heap, val: SLVa
  * (loc, loc+1) con los punteros izquierdo y derecho.
  */
 export declare function tree(root: SLValue): SLFormula;
+/** Comprueba si `heap` representa un árbol binario con raíz `root` (nodos de 2 celdas contiguas). */
 export declare function isTree(root: SLValue, heap: Heap): boolean;
 /** Frame rule: si `{P} c {Q}` y `c` no modifica las variables libres de
  * `R`, entonces `{P * R} c {Q * R}`. Esta función construye la tripla
  * compuesta — la validación queda a cargo de `checkTriple`. */
 export declare function frame(triple: SLTriple, frameFormula: SLFormula): SLTriple;
+/** Constructores convenientes para `SLCommand` (skip, assign, alloc, free, load, store). */
 export declare const Cmd: {
     skip: () => SLCommand;
     assign: (variable: string, value: SLValue) => SLCommand;

package/dist/reasoning/separation-logic/index.d.ts.map

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