@stevenvo780/st-lang 4.14.0 → 4.15.0

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

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const theorem_cache_1 = require("../../../runtime/theorem-cache");
+const persistence_1 = require("../persistence");
+function mkProof(profile = 'classical', cost = 10) {
+    return {
+        conclusion: 'P -> P',
+        premises: ['P'],
+        profile,
+        cost,
+        steps: [
+            { rule: 'MP', inputs: ['P->P', 'P'], output: 'P', depth: 0 },
+            { rule: 'axiom', inputs: [], output: 'P->P', depth: 1 },
+            { rule: 'axiom', inputs: [], output: 'P', depth: 1 },
+        ],
+    };
+}
+function mkLemma(id, statement, profile = 'classical') {
+    return {
+        id,
+        statement,
+        proof: mkProof(profile),
+        abstractionLevel: 1,
+        usageCount: 3,
+        savings: 27,
+        sourceProofs: ['proof-0', 'proof-1', 'proof-2'],
+    };
+}
+(0, vitest_1.describe)('persistLemmas', () => {
+    let cache;
+    (0, vitest_1.beforeEach)(() => {
+        cache = new theorem_cache_1.TheoremCache();
+    });
+    (0, vitest_1.it)('guarda un lemma y retorna su id', () => {
+        const lemma = mkLemma('l1', '?0 -> ?0');
+        const ids = (0, persistence_1.persistLemmas)([lemma], cache, () => 1717171717171);
+        (0, vitest_1.expect)(ids).toHaveLength(1);
+        (0, vitest_1.expect)(typeof ids[0]).toBe('string');
+    });
+    (0, vitest_1.it)('marca el lemma con provedBy = proof-mining', () => {
+        const lemma = mkLemma('l1', '?0 -> ?0');
+        (0, persistence_1.persistLemmas)([lemma], cache);
+        const th = cache.retrieve('?0 -> ?0', 'classical');
+        (0, vitest_1.expect)(th?.metadata.provedBy).toBe(persistence_1.MINED_LEMMA_PROVER);
+    });
+    (0, vitest_1.it)('guarda múltiples lemmas en batch', () => {
+        const lemmas = [
+            mkLemma('a', '?0 -> ?0'),
+            mkLemma('b', '?0 and ?1'),
+            mkLemma('c', '?0 or ?1'),
+        ];
+        const ids = (0, persistence_1.persistLemmas)(lemmas, cache);
+        (0, vitest_1.expect)(ids).toHaveLength(3);
+        (0, vitest_1.expect)(cache.stats().entries).toBe(3);
+    });
+});
+(0, vitest_1.describe)('recoverLemmaFromCache', () => {
+    (0, vitest_1.it)('devuelve undefined si la entry no es un mined lemma', () => {
+        const cache = new theorem_cache_1.TheoremCache();
+        const id = cache.store({
+            formula: 'P -> P',
+            normalizedFormula: '?0 -> ?0',
+            profile: 'classical',
+            proof: 'axiom',
+            metadata: {
+                provedAt: new Date().toISOString(),
+                ms: 5,
+                provedBy: 'other-prover',
+            },
+        });
+        const th = cache.retrieve('P -> P', 'classical');
+        (0, vitest_1.expect)(th).toBeDefined();
+        (0, vitest_1.expect)((0, persistence_1.recoverLemmaFromCache)(th)).toBeUndefined();
+        (0, vitest_1.expect)(id).toBeDefined();
+    });
+    (0, vitest_1.it)('reconstruye un MinedLemma desde el cache', () => {
+        const cache = new theorem_cache_1.TheoremCache();
+        const lemma = mkLemma('l1', '?0 -> ?0');
+        (0, persistence_1.persistLemmas)([lemma], cache);
+        const th = cache.retrieve('?0 -> ?0', 'classical');
+        (0, vitest_1.expect)(th).toBeDefined();
+        const recovered = (0, persistence_1.recoverLemmaFromCache)(th);
+        (0, vitest_1.expect)(recovered).toBeDefined();
+        (0, vitest_1.expect)(recovered?.statement).toBe('?0 -> ?0');
+        (0, vitest_1.expect)(recovered?.usageCount).toBe(3);
+        (0, vitest_1.expect)(recovered?.savings).toBe(27);
+        (0, vitest_1.expect)(recovered?.abstractionLevel).toBe(1);
+    });
+});
+(0, vitest_1.describe)('recoverLemmas', () => {
+    (0, vitest_1.it)('recupera múltiples lemmas dada la lista de statements esperados', () => {
+        const cache = new theorem_cache_1.TheoremCache();
+        const lemmas = [
+            mkLemma('a', '?0 -> ?0'),
+            mkLemma('b', '?0 and ?1'),
+        ];
+        (0, persistence_1.persistLemmas)(lemmas, cache);
+        const recovered = (0, persistence_1.recoverLemmas)(cache, [
+            { statement: '?0 -> ?0', profile: 'classical' },
+            { statement: '?0 and ?1', profile: 'classical' },
+            { statement: 'inexistente', profile: 'classical' },
+        ]);
+        (0, vitest_1.expect)(recovered).toHaveLength(2);
+    });
+    (0, vitest_1.it)('round-trip: persist + recover preserva datos clave', () => {
+        const cache = new theorem_cache_1.TheoremCache();
+        const original = mkLemma('a', '?0 -> ?0');
+        (0, persistence_1.persistLemmas)([original], cache);
+        const [recovered] = (0, persistence_1.recoverLemmas)(cache, [
+            { statement: '?0 -> ?0', profile: 'classical' },
+        ]);
+        (0, vitest_1.expect)(recovered).toBeDefined();
+        (0, vitest_1.expect)(recovered?.usageCount).toBe(original.usageCount);
+        (0, vitest_1.expect)(recovered?.savings).toBe(original.savings);
+        (0, vitest_1.expect)(recovered?.sourceProofs).toEqual(original.sourceProofs);
+    });
+});
+//# sourceMappingURL=persistence.test.js.map

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

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

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ranker.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ranker.test.d.ts","sourceRoot":"","sources":["../../../../src/reasoning/proof-mining/__tests__/ranker.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const ranker_1 = require("../ranker");
+function mkProof(profile = 'classical') {
+    return {
+        conclusion: 'X',
+        premises: [],
+        profile,
+        cost: 10,
+        steps: [{ rule: 'r', inputs: [], output: 'X', depth: 0 }],
+    };
+}
+function mkLemma(id, opts) {
+    return {
+        id,
+        statement: `lemma-${id}`,
+        proof: mkProof(),
+        abstractionLevel: opts.abstraction,
+        usageCount: opts.usage,
+        savings: opts.savings,
+        sourceProofs: [],
+    };
+}
+(0, vitest_1.describe)('scoreLemma', () => {
+    (0, vitest_1.it)('score aumenta con savings', () => {
+        const a = mkLemma('a', { usage: 1, savings: 0, abstraction: 0 });
+        const b = mkLemma('b', { usage: 1, savings: 100, abstraction: 0 });
+        (0, vitest_1.expect)((0, ranker_1.scoreLemma)(b)).toBeGreaterThan((0, ranker_1.scoreLemma)(a));
+    });
+    (0, vitest_1.it)('score aumenta con usageCount', () => {
+        const a = mkLemma('a', { usage: 2, savings: 10, abstraction: 0 });
+        const b = mkLemma('b', { usage: 20, savings: 10, abstraction: 0 });
+        (0, vitest_1.expect)((0, ranker_1.scoreLemma)(b)).toBeGreaterThan((0, ranker_1.scoreLemma)(a));
+    });
+    (0, vitest_1.it)('score aumenta con abstractionLevel', () => {
+        const a = mkLemma('a', { usage: 2, savings: 10, abstraction: 0 });
+        const b = mkLemma('b', { usage: 2, savings: 10, abstraction: 3 });
+        (0, vitest_1.expect)((0, ranker_1.scoreLemma)(b)).toBeGreaterThan((0, ranker_1.scoreLemma)(a));
+    });
+    (0, vitest_1.it)('weights override default', () => {
+        const lemma = mkLemma('a', { usage: 1, savings: 0, abstraction: 10 });
+        const baseScore = (0, ranker_1.scoreLemma)(lemma);
+        const boosted = (0, ranker_1.scoreLemma)(lemma, { generality: 1 });
+        (0, vitest_1.expect)(boosted).toBeGreaterThan(baseScore);
+    });
+});
+(0, vitest_1.describe)('rankLemmas', () => {
+    (0, vitest_1.it)('ordena descendente por score', () => {
+        const a = mkLemma('a', { usage: 1, savings: 0, abstraction: 0 });
+        const b = mkLemma('b', { usage: 10, savings: 100, abstraction: 2 });
+        const c = mkLemma('c', { usage: 5, savings: 50, abstraction: 1 });
+        const ranked = (0, ranker_1.rankLemmas)([a, b, c]);
+        (0, vitest_1.expect)(ranked[0]?.id).toBe('b');
+        (0, vitest_1.expect)(ranked[2]?.id).toBe('a');
+    });
+    (0, vitest_1.it)('en empate de score, mayor usageCount gana', () => {
+        const x = mkLemma('x', { usage: 5, savings: 10, abstraction: 1 });
+        const y = mkLemma('y', { usage: 5, savings: 10, abstraction: 1 });
+        const ranked = (0, ranker_1.rankLemmas)([x, y]);
+        // Misma score → orden por id asc (determinismo)
+        (0, vitest_1.expect)(ranked[0]?.id).toBe('x');
+    });
+    (0, vitest_1.it)('no muta el array original', () => {
+        const a = mkLemma('a', { usage: 1, savings: 0, abstraction: 0 });
+        const b = mkLemma('b', { usage: 10, savings: 100, abstraction: 2 });
+        const input = [a, b];
+        (0, ranker_1.rankLemmas)(input);
+        (0, vitest_1.expect)(input[0]?.id).toBe('a');
+        (0, vitest_1.expect)(input[1]?.id).toBe('b');
+    });
+});
+(0, vitest_1.describe)('topK', () => {
+    (0, vitest_1.it)('devuelve los primeros K', () => {
+        const lemmas = Array.from({ length: 10 }, (_, i) => mkLemma(`l${i}`, { usage: i, savings: i * 10, abstraction: 0 }));
+        const top3 = (0, ranker_1.topK)(lemmas, 3);
+        (0, vitest_1.expect)(top3).toHaveLength(3);
+        // El de mayor usage/savings (l9) debe estar primero.
+        (0, vitest_1.expect)(top3[0]?.id).toBe('l9');
+    });
+    (0, vitest_1.it)('K = 0 devuelve array vacío', () => {
+        const lemmas = [mkLemma('a', { usage: 1, savings: 0, abstraction: 0 })];
+        (0, vitest_1.expect)((0, ranker_1.topK)(lemmas, 0)).toHaveLength(0);
+    });
+    (0, vitest_1.it)('K mayor que la lista devuelve toda la lista', () => {
+        const lemmas = [
+            mkLemma('a', { usage: 1, savings: 0, abstraction: 0 }),
+            mkLemma('b', { usage: 2, savings: 0, abstraction: 0 }),
+        ];
+        (0, vitest_1.expect)((0, ranker_1.topK)(lemmas, 100)).toHaveLength(2);
+    });
+});
+//# sourceMappingURL=ranker.test.js.map

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

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

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

@@ -0,0 +1,73 @@
+import type { ProofStep, ProofTrace } from './types';
+/**
+ * Un sub-tree candidato extraído de un proof, antes de pasar a
+ * generalización/ranking.
+ */
+export interface SubtreeCandidate {
+    /** ID del proof origen. */
+    proofId: string;
+    /** Posición del paso raíz en `steps`. */
+    rootIndex: number;
+    /** Pasos que componen el sub-tree (en orden top-down). */
+    steps: ProofStep[];
+    /** Conclusión del sub-tree (= output del paso raíz). */
+    conclusion: string;
+    /** Profile del proof origen. */
+    profile: string;
+    /** Cost asignado (igual al cost del proof original prorrateado). */
+    cost: number;
+}
+/**
+ * Agrupación de sub-trees estructuralmente equivalentes.
+ */
+export interface SubtreeGroup {
+    /** Hash α-canónico común. */
+    key: string;
+    /** Conclusión canónica representativa. */
+    canonicalConclusion: string;
+    /** Sub-trees miembros del grupo. */
+    members: SubtreeCandidate[];
+}
+/**
+ * Descompone un proof en sub-trees a partir de cada paso. El
+ * sub-tree con raíz en `i` incluye `steps[i]` y todos los
+ * descendientes consecutivos (depth > steps[i].depth) hasta que
+ * vuelve a aparecer un paso de depth ≤ steps[i].depth.
+ *
+ * Para steps[i] con depth d_i, el sub-tree es:
+ *   steps[i], steps[i+1], …, steps[j-1]
+ * donde j es el menor índice > i con steps[j].depth ≤ d_i (o
+ * length si no existe).
+ */
+export declare function extractSubtrees(proof: ProofTrace, proofId: string): SubtreeCandidate[];
+/**
+ * Clave estructural canónica de un sub-tree.
+ *
+ * Combina: secuencia de reglas (por orden top-down) + diferencias
+ * relativas de depth (para reconstruir forma del árbol) + outputs
+ * normalizados α-canónicamente.
+ *
+ * El canónico depende del orden de aparición de los identificadores
+ * de cada output, lo que da un hash estable módulo renombrado de
+ * variables.
+ */
+export declare function subtreeKey(sub: SubtreeCandidate): string;
+/**
+ * Agrupa sub-trees por clave estructural canónica.
+ */
+export declare function groupSubtrees(candidates: SubtreeCandidate[]): SubtreeGroup[];
+/**
+ * Identifica sub-pruebas auxiliares en el corpus. Recibe un array
+ * de proofs, devuelve los grupos de sub-trees estructuralmente
+ * equivalentes que pasan los filtros (minReuseThreshold y
+ * minSubtreeSize).
+ *
+ * Esta función NO genera lemmas todavía — solo identifica los
+ * candidatos. `mineLemmas` los procesa, genera el statement y los
+ * persiste.
+ */
+export declare function extractAuxiliaryLemmas(corpus: ProofTrace[], options?: {
+    minReuseThreshold?: number;
+    minSubtreeSize?: number;
+}): SubtreeGroup[];
+//# sourceMappingURL=extractor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extractor.d.ts","sourceRoot":"","sources":["../../../src/reasoning/proof-mining/extractor.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErD;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,2BAA2B;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,yCAAyC;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,0DAA0D;IAC1D,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,wDAAwD;IACxD,UAAU,EAAE,MAAM,CAAC;IACnB,gCAAgC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,6BAA6B;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,0CAA0C;IAC1C,mBAAmB,EAAE,MAAM,CAAC;IAC5B,oCAAoC;IACpC,OAAO,EAAE,gBAAgB,EAAE,CAAC;CAC7B;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,gBAAgB,EAAE,CA8BtF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,gBAAgB,GAAG,MAAM,CAoBxD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,gBAAgB,EAAE,GAAG,YAAY,EAAE,CAgB5E;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,UAAU,EAAE,EACpB,OAAO,CAAC,EAAE;IAAE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,GAChE,YAAY,EAAE,CA2BhB"}

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

@@ -0,0 +1,170 @@
+"use strict";
+// ============================================================
+// ST Proof Mining — Extracción de sub-pruebas reutilizables
+// ============================================================
+//
+// Algoritmo:
+//
+//   1. Para cada proof P en el corpus, descomponer en sub-trees.
+//      Un sub-tree comienza en un paso s y abarca todos los pasos
+//      con depth > s.depth hasta que aparezca otro paso de depth
+//      ≤ s.depth (regreso al nivel del padre).
+//
+//   2. Para cada sub-tree, calcular una clave estructural (hash
+//      α-canónico): la secuencia de reglas + outputs normalizados a
+//      placeholders `?0`, `?1`, …
+//
+//   3. Agrupar sub-trees por clave. Los grupos con count ≥
+//      minReuseThreshold y size ≥ minSubtreeSize son candidatos
+//      a lemma.
+//
+// La descomposición es lineal en el tamaño del proof: cada paso
+// participa en O(1) sub-trees (el que arranca en él) — aunque cada
+// sub-tree puede tener O(size) pasos. Total: O(N · S) donde S es
+// el tamaño promedio del sub-tree (usualmente pequeño).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractSubtrees = extractSubtrees;
+exports.subtreeKey = subtreeKey;
+exports.groupSubtrees = groupSubtrees;
+exports.extractAuxiliaryLemmas = extractAuxiliaryLemmas;
+const canonical_1 = require("../../runtime/theorem-cache/canonical");
+function genProofId(p, idx) {
+    return p.id ?? `proof-${idx}`;
+}
+/**
+ * Descompone un proof en sub-trees a partir de cada paso. El
+ * sub-tree con raíz en `i` incluye `steps[i]` y todos los
+ * descendientes consecutivos (depth > steps[i].depth) hasta que
+ * vuelve a aparecer un paso de depth ≤ steps[i].depth.
+ *
+ * Para steps[i] con depth d_i, el sub-tree es:
+ *   steps[i], steps[i+1], …, steps[j-1]
+ * donde j es el menor índice > i con steps[j].depth ≤ d_i (o
+ * length si no existe).
+ */
+function extractSubtrees(proof, proofId) {
+    const out = [];
+    const steps = proof.steps;
+    if (steps.length === 0)
+        return out;
+    // Cost prorrateado: cada paso aporta cost/length al sub-tree donde participa.
+    const perStepCost = proof.cost / Math.max(1, steps.length);
+    for (let i = 0; i < steps.length; i++) {
+        const root = steps[i];
+        if (root === undefined)
+            continue;
+        const rootDepth = root.depth;
+        let j = i + 1;
+        while (j < steps.length) {
+            const sj = steps[j];
+            if (sj === undefined)
+                break;
+            if (sj.depth <= rootDepth)
+                break;
+            j++;
+        }
+        const subSteps = steps.slice(i, j);
+        out.push({
+            proofId,
+            rootIndex: i,
+            steps: subSteps,
+            conclusion: root.output,
+            profile: proof.profile,
+            cost: perStepCost * subSteps.length,
+        });
+    }
+    return out;
+}
+/**
+ * Clave estructural canónica de un sub-tree.
+ *
+ * Combina: secuencia de reglas (por orden top-down) + diferencias
+ * relativas de depth (para reconstruir forma del árbol) + outputs
+ * normalizados α-canónicamente.
+ *
+ * El canónico depende del orden de aparición de los identificadores
+ * de cada output, lo que da un hash estable módulo renombrado de
+ * variables.
+ */
+function subtreeKey(sub) {
+    if (sub.steps.length === 0)
+        return 'empty';
+    const root = sub.steps[0];
+    if (root === undefined)
+        return 'empty';
+    const baseDepth = root.depth;
+    const parts = [];
+    // Renombrado coherente de identificadores a través de todos los outputs
+    // del sub-tree. Concatenamos con separador para que aparezcan en el orden
+    // correcto y un único pase de canonicalización los renombra de forma
+    // consistente.
+    const joined = sub.steps.map((s) => s.output).join(' ⫶ ');
+    const canon = (0, canonical_1.canonicalString)(joined);
+    const outputs = canon.split(' ⫶ ');
+    for (let i = 0; i < sub.steps.length; i++) {
+        const s = sub.steps[i];
+        if (s === undefined)
+            continue;
+        const out = outputs[i] ?? (0, canonical_1.canonicalString)(s.output);
+        parts.push(`${s.rule}@${s.depth - baseDepth}:${out}`);
+    }
+    return parts.join('|');
+}
+/**
+ * Agrupa sub-trees por clave estructural canónica.
+ */
+function groupSubtrees(candidates) {
+    const groups = new Map();
+    for (const c of candidates) {
+        const k = subtreeKey(c);
+        let g = groups.get(k);
+        if (g === undefined) {
+            g = {
+                key: k,
+                canonicalConclusion: (0, canonical_1.canonicalString)(c.conclusion),
+                members: [],
+            };
+            groups.set(k, g);
+        }
+        g.members.push(c);
+    }
+    return Array.from(groups.values());
+}
+/**
+ * Identifica sub-pruebas auxiliares en el corpus. Recibe un array
+ * de proofs, devuelve los grupos de sub-trees estructuralmente
+ * equivalentes que pasan los filtros (minReuseThreshold y
+ * minSubtreeSize).
+ *
+ * Esta función NO genera lemmas todavía — solo identifica los
+ * candidatos. `mineLemmas` los procesa, genera el statement y los
+ * persiste.
+ */
+function extractAuxiliaryLemmas(corpus, options) {
+    const minReuse = options?.minReuseThreshold ?? 2;
+    const minSize = options?.minSubtreeSize ?? 2;
+    const allSubtrees = [];
+    for (let i = 0; i < corpus.length; i++) {
+        const p = corpus[i];
+        if (p === undefined)
+            continue;
+        const id = genProofId(p, i);
+        for (const sub of extractSubtrees(p, id)) {
+            if (sub.steps.length < minSize)
+                continue;
+            allSubtrees.push(sub);
+        }
+    }
+    const groups = groupSubtrees(allSubtrees);
+    // Filtrar por umbral de reuso, contando proofs DISTINTOS (no
+    // múltiples ocurrencias dentro del mismo proof).
+    const filtered = [];
+    for (const g of groups) {
+        const distinctProofs = new Set(g.members.map((m) => m.proofId));
+        if (distinctProofs.size >= minReuse) {
+            filtered.push(g);
+        }
+    }
+    return filtered;
+}
+//# sourceMappingURL=extractor.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extractor.js","sourceRoot":"","sources":["../../../src/reasoning/proof-mining/extractor.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,4DAA4D;AAC5D,+DAA+D;AAC/D,EAAE;AACF,aAAa;AACb,EAAE;AACF,iEAAiE;AACjE,kEAAkE;AAClE,iEAAiE;AACjE,+CAA+C;AAC/C,EAAE;AACF,gEAAgE;AAChE,oEAAoE;AACpE,kCAAkC;AAClC,EAAE;AACF,2DAA2D;AAC3D,gEAAgE;AAChE,gBAAgB;AAChB,EAAE;AACF,gEAAgE;AAChE,mEAAmE;AACnE,iEAAiE;AACjE,wDAAwD;;AAmDxD,0CA8BC;AAaD,gCAoBC;AAKD,sCAgBC;AAYD,wDA8BC;AA/KD,qEAAwE;AAkCxE,SAAS,UAAU,CAAC,CAAa,EAAE,GAAW;IAC5C,OAAO,CAAC,CAAC,EAAE,IAAI,SAAS,GAAG,EAAE,CAAC;AAChC,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,eAAe,CAAC,KAAiB,EAAE,OAAe;IAChE,MAAM,GAAG,GAAuB,EAAE,CAAC;IACnC,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;IAC1B,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,GAAG,CAAC;IAEnC,8EAA8E;IAC9E,MAAM,WAAW,GAAG,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAE3D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACtB,IAAI,IAAI,KAAK,SAAS;YAAE,SAAS;QACjC,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC;QAC7B,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACd,OAAO,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;YACxB,MAAM,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACpB,IAAI,EAAE,KAAK,SAAS;gBAAE,MAAM;YAC5B,IAAI,EAAE,CAAC,KAAK,IAAI,SAAS;gBAAE,MAAM;YACjC,CAAC,EAAE,CAAC;QACN,CAAC;QACD,MAAM,QAAQ,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACnC,GAAG,CAAC,IAAI,CAAC;YACP,OAAO;YACP,SAAS,EAAE,CAAC;YACZ,KAAK,EAAE,QAAQ;YACf,UAAU,EAAE,IAAI,CAAC,MAAM;YACvB,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,IAAI,EAAE,WAAW,GAAG,QAAQ,CAAC,MAAM;SACpC,CAAC,CAAC;IACL,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,UAAU,CAAC,GAAqB;IAC9C,IAAI,GAAG,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,OAAO,CAAC;IAC3C,MAAM,IAAI,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC1B,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,OAAO,CAAC;IACvC,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC;IAC7B,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,wEAAwE;IACxE,0EAA0E;IAC1E,qEAAqE;IACrE,eAAe;IACf,MAAM,MAAM,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC1D,MAAM,KAAK,GAAG,IAAA,2BAAe,EAAC,MAAM,CAAC,CAAC;IACtC,MAAM,OAAO,GAAG,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACnC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC1C,MAAM,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACvB,IAAI,CAAC,KAAK,SAAS;YAAE,SAAS;QAC9B,MAAM,GAAG,GAAG,OAAO,CAAC,CAAC,CAAC,IAAI,IAAA,2BAAe,EAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QACpD,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,KAAK,GAAG,SAAS,IAAI,GAAG,EAAE,CAAC,CAAC;IACxD,CAAC;IACD,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACzB,CAAC;AAED;;GAEG;AACH,SAAgB,aAAa,CAAC,UAA8B;IAC1D,MAAM,MAAM,GAAG,IAAI,GAAG,EAAwB,CAAC;IAC/C,KAAK,MAAM,CAAC,IAAI,UAAU,EAAE,CAAC;QAC3B,MAAM,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;QACxB,IAAI,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACtB,IAAI,CAAC,KAAK,SAAS,EAAE,CAAC;YACpB,CAAC,GAAG;gBACF,GAAG,EAAE,CAAC;gBACN,mBAAmB,EAAE,IAAA,2BAAe,EAAC,CAAC,CAAC,UAAU,CAAC;gBAClD,OAAO,EAAE,EAAE;aACZ,CAAC;YACF,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACnB,CAAC;QACD,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACpB,CAAC;IACD,OAAO,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;AACrC,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,sBAAsB,CACpC,MAAoB,EACpB,OAAiE;IAEjE,MAAM,QAAQ,GAAG,OAAO,EAAE,iBAAiB,IAAI,CAAC,CAAC;IACjD,MAAM,OAAO,GAAG,OAAO,EAAE,cAAc,IAAI,CAAC,CAAC;IAE7C,MAAM,WAAW,GAAuB,EAAE,CAAC;IAC3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACvC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACpB,IAAI,CAAC,KAAK,SAAS;YAAE,SAAS;QAC9B,MAAM,EAAE,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAC5B,KAAK,MAAM,GAAG,IAAI,eAAe,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;YACzC,IAAI,GAAG,CAAC,KAAK,CAAC,MAAM,GAAG,OAAO;gBAAE,SAAS;YACzC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACxB,CAAC;IACH,CAAC;IAED,MAAM,MAAM,GAAG,aAAa,CAAC,WAAW,CAAC,CAAC;IAE1C,6DAA6D;IAC7D,iDAAiD;IACjD,MAAM,QAAQ,GAAmB,EAAE,CAAC;IACpC,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;QACvB,MAAM,cAAc,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;QAChE,IAAI,cAAc,CAAC,IAAI,IAAI,QAAQ,EAAE,CAAC;YACpC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACnB,CAAC;IACH,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC"}

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

@@ -0,0 +1,46 @@
+import type { Term, FreshSupply } from '../../runtime/anti-unification';
+/**
+ * Resultado de generalización: el statement (puede ser string con
+ * placeholders fresh), el conteo de variables abstractas
+ * introducidas y un flag de si la generalización es no-trivial
+ * (e.g. produjo placeholders).
+ */
+export interface GeneralizationResult {
+    statement: string;
+    abstractionLevel: number;
+    nonTrivial: boolean;
+}
+/**
+ * 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`.
+ */
+export declare function generalizeTerms(instances: Term[], freshSupply?: FreshSupply): GeneralizationResult;
+/**
+ * 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.
+ */
+export declare function generalizeFormulas(instances: string[]): GeneralizationResult;
+/**
+ * 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.
+ */
+export declare function generalizeLemma(conclusions: string[], options?: {
+    maxAbstractionLevel?: number;
+    preserveSemantic?: boolean;
+}): GeneralizationResult;
+//# sourceMappingURL=generalizer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generalizer.d.ts","sourceRoot":"","sources":["../../../src/reasoning/proof-mining/generalizer.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAExE;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,IAAI,EAAE,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,oBAAoB,CAkBlG;AAmDD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,oBAAoB,CA8D5E;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,WAAW,EAAE,MAAM,EAAE,EACrB,OAAO,CAAC,EAAE;IAAE,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAAE,GACrE,oBAAoB,CA2BtB"}