@stevenvo780/st-lang 4.14.1 → 4.15.0

package/dist/reasoning/lemma-rag/retrieval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retrieval.d.ts","sourceRoot":"","sources":["../../../src/reasoning/lemma-rag/retrieval.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AACrE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAOhD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,MAAM,CAQnE;AAUD;;;GAGG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,aAAa,EAAE,KAAK,EAAE,UAAU,GAAG,MAAM,CA6B1F;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,GACnB,MAAM,CAGR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,SAAS,EACnB,KAAK,EAAE,UAAU,EACjB,CAAC,EAAE,MAAM,EACT,YAAY,EAAE,MAAM,EACpB,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,SAAI,GACX,WAAW,EAAE,CAoCf"}

package/dist/reasoning/lemma-rag/retrieval.js

@@ -0,0 +1,123 @@
+"use strict";
+// ============================================================
+// Retrieval — cosine similarity + BM25 hybrid scoring
+//
+// Implementa:
+//   - cosineSimilarity(a, b): dot product de vectores ya normalizados
+//   - bm25Score(query, doc, store): BM25 Okapi sobre el inverted index
+//   - hybridScore: 0.7 * cosine + 0.3 * bm25_normalizado
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cosineSimilarity = cosineSimilarity;
+exports.bm25Score = bm25Score;
+exports.hybridScore = hybridScore;
+exports.retrieveTopK = retrieveTopK;
+const tokenize_1 = require("../../tooling/lemma-library/tokenize");
+// BM25 parámetros estándar
+const BM25_K1 = 1.5;
+const BM25_B = 0.75;
+/**
+ * Cosine similarity entre dos vectores NORMALIZADOS (norma L2 = 1).
+ * En ese caso, es simplemente el producto punto.
+ * Devuelve un valor en [-1, 1], saturado a [0, 1] para usarse como score.
+ */
+function cosineSimilarity(a, b) {
+    if (a.length !== b.length)
+        return 0;
+    let dot = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += (a[i] ?? 0) * (b[i] ?? 0);
+    }
+    // saturar a [0, 1] — embeddings de texto raramente son negativos
+    return Math.max(0, Math.min(1, dot));
+}
+/**
+ * IDF suavizado estándar: log((N - df + 0.5) / (df + 0.5) + 1)
+ * Siempre positivo.
+ */
+function idf(df, N) {
+    return Math.log((N - df + 0.5) / (df + 0.5) + 1);
+}
+/**
+ * BM25 Okapi score de una query contra un documento en el store.
+ * Devuelve un score ≥ 0.
+ */
+function bm25Score(queryText, doc, store) {
+    const queryTokens = (0, tokenize_1.tokenize)(queryText);
+    if (queryTokens.length === 0)
+        return 0;
+    const N = store.totalDocs();
+    if (N === 0)
+        return 0;
+    const avgdl = store.avgDocLength();
+    const dl = doc.docLength;
+    let score = 0;
+    const seen = new Set();
+    for (const tok of queryTokens) {
+        if (seen.has(tok))
+            continue;
+        seen.add(tok);
+        const tf = doc.termFreq.get(tok) ?? 0;
+        if (tf === 0)
+            continue;
+        const df = store.getDocFreq(tok);
+        const termIdf = idf(df, N);
+        // BM25 TF component: tf * (k1 + 1) / (tf + k1 * (1 - b + b * dl/avgdl))
+        const tfComp = (tf * (BM25_K1 + 1)) / (tf + BM25_K1 * (1 - BM25_B + BM25_B * (dl / avgdl)));
+        score += termIdf * tfComp;
+    }
+    return score;
+}
+/**
+ * Score híbrido: `cosineWeight * cosine + (1 - cosineWeight) * bm25_norm`.
+ *
+ * BM25 se normaliza dividiendo por `maxBm25` (máximo observado en el batch).
+ * Si maxBm25 === 0, el componente BM25 aporta 0.
+ */
+function hybridScore(cosine, bm25, maxBm25, cosineWeight) {
+    const bm25Norm = maxBm25 > 0 ? bm25 / maxBm25 : 0;
+    return cosineWeight * cosine + (1 - cosineWeight) * bm25Norm;
+}
+/**
+ * Recupera los top-k lemas del store para una query dada.
+ *
+ * @param queryText  - Texto de la query (fórmula o descripción)
+ * @param queryVec   - Embedding pre-calculado de queryText
+ * @param store      - IndexStore con los lemas indexados
+ * @param k          - Número de resultados
+ * @param cosineWeight - Peso del componente cosine (default 0.7)
+ * @param domain     - Filtro opcional de dominio
+ * @param minScore   - Score mínimo para incluir
+ */
+function retrieveTopK(queryText, queryVec, store, k, cosineWeight, domain, minScore = 0) {
+    const candidates = domain ? store.byDomain(domain) : store.all();
+    if (candidates.length === 0)
+        return [];
+    // Paso 1: calcular scores individuales
+    const intermediate = [];
+    let maxBm25 = 0;
+    for (const entry of candidates) {
+        const cos = cosineSimilarity(queryVec, entry.embedding);
+        const bm = bm25Score(queryText, entry, store);
+        if (bm > maxBm25)
+            maxBm25 = bm;
+        intermediate.push({ entry, cosine: cos, bm25: bm });
+    }
+    // Paso 2: calcular score híbrido y filtrar
+    const results = [];
+    for (const { entry, cosine, bm25: bm } of intermediate) {
+        const score = hybridScore(cosine, bm, maxBm25, cosineWeight);
+        if (score >= minScore) {
+            results.push({
+                lemma: entry.lemma,
+                score,
+                cosineScore: cosine,
+                bm25Score: bm,
+            });
+        }
+    }
+    // Paso 3: ordenar por score desc, desempate por id
+    results.sort((a, b) => b.score - a.score || a.lemma.id.localeCompare(b.lemma.id));
+    return results.slice(0, k);
+}
+//# sourceMappingURL=retrieval.js.map

package/dist/reasoning/lemma-rag/retrieval.js.map

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

package/dist/reasoning/lemma-rag/types.d.ts

@@ -0,0 +1,52 @@
+import type { CuratedLemma } from '../../tooling/lemma-library/types';
+/** Dimensión del espacio de embedding (R^DIM). */
+export declare const EMBEDDING_DIM = 256;
+/**
+ * Vector de embedding: arreglo de DIM floats en R^DIM.
+ * Siempre normalizado a norma 1 (L2) antes de ser usado en comparaciones.
+ */
+export type Embedding = Float32Array;
+/** Lema con su embedding pre-calculado. */
+export interface EmbeddedLemma {
+    lemma: CuratedLemma;
+    embedding: Embedding;
+    /** BM25 token bag para el componente léxico del scoring híbrido. */
+    termFreq: Map<string, number>;
+    /** Total de tokens en este documento (para BM25). */
+    docLength: number;
+}
+/** Un resultado de búsqueda con scores desglosados. */
+export interface QueryResult {
+    lemma: CuratedLemma;
+    /** Score híbrido final: 0.7 * cosine + 0.3 * bm25 (normalizado). */
+    score: number;
+    /** Score cosine (0..1). */
+    cosineScore: number;
+    /** Score BM25 antes de normalización (≥ 0). */
+    bm25Score: number;
+}
+/** Opciones para la búsqueda RAG. */
+export interface RAGOptions {
+    /** Top-k resultados a devolver (default 5). */
+    k?: number;
+    /** Peso del componente cosine en el score híbrido (default 0.7). */
+    cosineWeight?: number;
+    /** Filtrar por dominio antes de buscar. */
+    domain?: string;
+    /** Score mínimo para incluir un resultado (default 0). */
+    minScore?: number;
+}
+/** Provider de embeddings (interface para Stage 2). */
+export interface EmbeddingProvider {
+    embed(text: string): Embedding;
+    dim: number;
+}
+/** Resultado del benchmark de recall. */
+export interface RecallResult {
+    method: 'keyword' | 'embedding' | 'hybrid';
+    recallAt1: number;
+    recallAt3: number;
+    recallAt5: number;
+    totalPairs: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/reasoning/lemma-rag/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/reasoning/lemma-rag/types.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAEtE,kDAAkD;AAClD,eAAO,MAAM,aAAa,MAAM,CAAC;AAEjC;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,YAAY,CAAC;AAErC,2CAA2C;AAC3C,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,YAAY,CAAC;IACpB,SAAS,EAAE,SAAS,CAAC;IACrB,oEAAoE;IACpE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,qDAAqD;IACrD,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,uDAAuD;AACvD,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,YAAY,CAAC;IACpB,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAC;IACd,2BAA2B;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,+CAA+C;IAC/C,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qCAAqC;AACrC,MAAM,WAAW,UAAU;IACzB,+CAA+C;IAC/C,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,oEAAoE;IACpE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2CAA2C;IAC3C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,uDAAuD;AACvD,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,GAAG,EAAE,MAAM,CAAC;CACb;AAED,yCAAyC;AACzC,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAC;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB"}

package/dist/reasoning/lemma-rag/types.js

@@ -0,0 +1,13 @@
+"use strict";
+// ============================================================
+// lemma-rag — Tipos públicos
+//
+// Tipos para el sistema RAG semántico sobre la biblioteca de lemas.
+// Embeddings determinísticos basados en AST features (Stage 1).
+// Stage 2 (ONNX transformers) pendiente de aprobación.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMBEDDING_DIM = void 0;
+/** Dimensión del espacio de embedding (R^DIM). */
+exports.EMBEDDING_DIM = 256;
+//# sourceMappingURL=types.js.map

package/dist/reasoning/lemma-rag/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/reasoning/lemma-rag/types.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,6BAA6B;AAC7B,EAAE;AACF,oEAAoE;AACpE,gEAAgE;AAChE,uDAAuD;AACvD,+DAA+D;;;AAI/D,kDAAkD;AACrC,QAAA,aAAa,GAAG,GAAG,CAAC"}

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

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

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

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

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

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const extractor_1 = require("../extractor");
+function trace(conclusion, steps, cost = 10, profile = 'classical', premises = []) {
+    return {
+        conclusion,
+        premises,
+        profile,
+        cost,
+        steps: steps.map(([rule, inputs, output, depth]) => ({
+            rule,
+            inputs,
+            output,
+            depth,
+        })),
+    };
+}
+(0, vitest_1.describe)('extractSubtrees', () => {
+    (0, vitest_1.it)('devuelve array vacío si el proof no tiene pasos', () => {
+        const p = trace('X', []);
+        (0, vitest_1.expect)((0, extractor_1.extractSubtrees)(p, 'p1')).toEqual([]);
+    });
+    (0, vitest_1.it)('genera un sub-tree por paso del proof', () => {
+        const p = trace('X', [
+            ['MP', ['A->B', 'A'], 'B', 0],
+            ['axiom', [], 'A->B', 1],
+            ['axiom', [], 'A', 1],
+        ]);
+        const subs = (0, extractor_1.extractSubtrees)(p, 'p1');
+        (0, vitest_1.expect)(subs).toHaveLength(3);
+    });
+    (0, vitest_1.it)('el sub-tree raíz cubre todos los pasos', () => {
+        const p = trace('X', [
+            ['MP', ['A->B', 'A'], 'B', 0],
+            ['axiom', [], 'A->B', 1],
+            ['axiom', [], 'A', 1],
+        ]);
+        const root = (0, extractor_1.extractSubtrees)(p, 'p1')[0];
+        (0, vitest_1.expect)(root).toBeDefined();
+        (0, vitest_1.expect)(root?.steps).toHaveLength(3);
+    });
+    (0, vitest_1.it)('un sub-tree de hoja solo contiene un paso', () => {
+        const p = trace('X', [
+            ['MP', ['A->B', 'A'], 'B', 0],
+            ['axiom', [], 'A->B', 1],
+            ['axiom', [], 'A', 1],
+        ]);
+        const subs = (0, extractor_1.extractSubtrees)(p, 'p1');
+        const leaf = subs[2];
+        (0, vitest_1.expect)(leaf?.steps).toHaveLength(1);
+        (0, vitest_1.expect)(leaf?.steps[0]?.rule).toBe('axiom');
+    });
+    (0, vitest_1.it)('respeta el corte por depth cuando hay hermanos', () => {
+        // Árbol: A tiene hijos B y C; B tiene hijo D
+        //   A(0)
+        //   ├ B(1)
+        //   │  └ D(2)
+        //   └ C(1)
+        const p = trace('A', [
+            ['rA', ['B', 'C'], 'A', 0],
+            ['rB', ['D'], 'B', 1],
+            ['rD', [], 'D', 2],
+            ['rC', [], 'C', 1],
+        ]);
+        const subs = (0, extractor_1.extractSubtrees)(p, 'p1');
+        // sub raíz en B: incluye B y D, no C
+        const subB = subs[1];
+        (0, vitest_1.expect)(subB?.steps.map((s) => s.output)).toEqual(['B', 'D']);
+        // sub raíz en C: solo C
+        const subC = subs[3];
+        (0, vitest_1.expect)(subC?.steps).toHaveLength(1);
+        (0, vitest_1.expect)(subC?.steps[0]?.output).toBe('C');
+    });
+});
+(0, vitest_1.describe)('subtreeKey', () => {
+    (0, vitest_1.it)('asigna la misma clave a sub-trees estructuralmente idénticos', () => {
+        const p1 = trace('X', [
+            ['MP', ['P->P', 'P'], 'P', 0],
+            ['axiom', [], 'P->P', 1],
+            ['axiom', [], 'P', 1],
+        ]);
+        const p2 = trace('X', [
+            ['MP', ['Q->Q', 'Q'], 'Q', 0],
+            ['axiom', [], 'Q->Q', 1],
+            ['axiom', [], 'Q', 1],
+        ]);
+        const sub1 = (0, extractor_1.extractSubtrees)(p1, 'p1')[0];
+        const sub2 = (0, extractor_1.extractSubtrees)(p2, 'p2')[0];
+        (0, vitest_1.expect)(sub1).toBeDefined();
+        (0, vitest_1.expect)(sub2).toBeDefined();
+        (0, vitest_1.expect)((0, extractor_1.subtreeKey)(sub1)).toBe((0, extractor_1.subtreeKey)(sub2));
+    });
+    (0, vitest_1.it)('asigna distinta clave a sub-trees con distinta regla', () => {
+        const p1 = trace('X', [
+            ['MP', ['A->B', 'A'], 'B', 0],
+            ['axiom', [], 'A->B', 1],
+            ['axiom', [], 'A', 1],
+        ]);
+        const p2 = trace('X', [
+            ['andI', ['A', 'B'], 'A and B', 0],
+            ['axiom', [], 'A', 1],
+            ['axiom', [], 'B', 1],
+        ]);
+        (0, vitest_1.expect)((0, extractor_1.subtreeKey)((0, extractor_1.extractSubtrees)(p1, 'p1')[0])).not.toBe((0, extractor_1.subtreeKey)((0, extractor_1.extractSubtrees)(p2, 'p2')[0]));
+    });
+});
+(0, vitest_1.describe)('groupSubtrees', () => {
+    (0, vitest_1.it)('agrupa por clave canónica', () => {
+        const p1 = trace('X', [
+            ['MP', ['P->P', 'P'], 'P', 0],
+            ['axiom', [], 'P->P', 1],
+            ['axiom', [], 'P', 1],
+        ]);
+        const p2 = trace('X', [
+            ['MP', ['R->R', 'R'], 'R', 0],
+            ['axiom', [], 'R->R', 1],
+            ['axiom', [], 'R', 1],
+        ]);
+        const sub1 = (0, extractor_1.extractSubtrees)(p1, 'p1');
+        const sub2 = (0, extractor_1.extractSubtrees)(p2, 'p2');
+        const groups = (0, extractor_1.groupSubtrees)([...sub1, ...sub2]);
+        // los 3 sub-trees de p1 deberían tener al menos 1 par equivalente en p2
+        const sized3 = groups.filter((g) => g.members.length >= 2);
+        (0, vitest_1.expect)(sized3.length).toBeGreaterThan(0);
+    });
+});
+(0, vitest_1.describe)('extractAuxiliaryLemmas', () => {
+    (0, vitest_1.it)('encuentra lemmas comunes a 2 proofs con misma estructura', () => {
+        const p1 = trace('X', [
+            ['MP', ['P->P', 'P'], 'P', 0],
+            ['axiom', [], 'P->P', 1],
+            ['axiom', [], 'P', 1],
+        ]);
+        const p2 = trace('Y', [
+            ['MP', ['Q->Q', 'Q'], 'Q', 0],
+            ['axiom', [], 'Q->Q', 1],
+            ['axiom', [], 'Q', 1],
+        ]);
+        const groups = (0, extractor_1.extractAuxiliaryLemmas)([p1, p2]);
+        (0, vitest_1.expect)(groups.length).toBeGreaterThan(0);
+        const root = groups.find((g) => g.members.some((m) => m.steps.length === 3));
+        (0, vitest_1.expect)(root).toBeDefined();
+        (0, vitest_1.expect)(root?.members.length).toBe(2);
+    });
+    (0, vitest_1.it)('respeta minReuseThreshold = 3 (no extrae si solo aparece 2 veces)', () => {
+        const p1 = trace('X', [
+            ['MP', ['P->P', 'P'], 'P', 0],
+            ['axiom', [], 'P->P', 1],
+            ['axiom', [], 'P', 1],
+        ]);
+        const p2 = trace('Y', [
+            ['MP', ['Q->Q', 'Q'], 'Q', 0],
+            ['axiom', [], 'Q->Q', 1],
+            ['axiom', [], 'Q', 1],
+        ]);
+        const groups = (0, extractor_1.extractAuxiliaryLemmas)([p1, p2], { minReuseThreshold: 3 });
+        (0, vitest_1.expect)(groups).toHaveLength(0);
+    });
+    (0, vitest_1.it)('respeta minSubtreeSize = 3 (filtra sub-trees pequeños)', () => {
+        const p1 = trace('X', [
+            ['MP', ['A->B', 'A'], 'B', 0],
+            ['axiom', [], 'A->B', 1],
+        ]);
+        const p2 = trace('Y', [
+            ['MP', ['C->D', 'C'], 'D', 0],
+            ['axiom', [], 'C->D', 1],
+        ]);
+        // Ningún sub-tree tiene >= 3 pasos.
+        const groups = (0, extractor_1.extractAuxiliaryLemmas)([p1, p2], { minSubtreeSize: 3 });
+        (0, vitest_1.expect)(groups).toHaveLength(0);
+    });
+    (0, vitest_1.it)('cuenta proofs distintos, no ocurrencias múltiples dentro del mismo proof', () => {
+        // Dos sub-trees idénticos dentro del MISMO proof no califican.
+        const p1 = trace('X', [
+            ['andI', ['A=A', 'A=A'], '(A=A) and (A=A)', 0],
+            ['refl', [], 'A=A', 1],
+            ['refl', [], 'A=A', 1],
+        ]);
+        const groups = (0, extractor_1.extractAuxiliaryLemmas)([p1], { minReuseThreshold: 2 });
+        (0, vitest_1.expect)(groups).toHaveLength(0);
+    });
+    (0, vitest_1.it)('extrae con 1 proof si minReuseThreshold = 1', () => {
+        const p1 = trace('X', [
+            ['MP', ['A->B', 'A'], 'B', 0],
+            ['axiom', [], 'A->B', 1],
+            ['axiom', [], 'A', 1],
+        ]);
+        const groups = (0, extractor_1.extractAuxiliaryLemmas)([p1], {
+            minReuseThreshold: 1,
+            minSubtreeSize: 2,
+        });
+        (0, vitest_1.expect)(groups.length).toBeGreaterThanOrEqual(1);
+    });
+    (0, vitest_1.it)('agrupa correctamente cuando 3 proofs comparten un sub-tree', () => {
+        const makeP = (label) => trace(label, [
+            ['MP', [`${label}->${label}`, label], label, 0],
+            ['axiom', [], `${label}->${label}`, 1],
+            ['axiom', [], label, 1],
+        ]);
+        const groups = (0, extractor_1.extractAuxiliaryLemmas)([makeP('P'), makeP('Q'), makeP('R')]);
+        // El sub-tree raíz debería tener 3 miembros (uno por proof).
+        const root = groups.find((g) => g.members.some((m) => m.steps.length === 3));
+        (0, vitest_1.expect)(root?.members.length).toBe(3);
+    });
+    (0, vitest_1.it)('proofs sin solapamiento estructural no producen lemmas', () => {
+        const p1 = trace('X', [
+            ['MP', ['A->B', 'A'], 'B', 0],
+            ['axiom', [], 'A->B', 1],
+            ['axiom', [], 'A', 1],
+        ]);
+        const p2 = trace('Y', [
+            ['andE', ['A and B'], 'A', 0],
+            ['axiom', [], 'A and B', 1],
+        ]);
+        (0, vitest_1.expect)((0, extractor_1.extractAuxiliaryLemmas)([p1, p2])).toHaveLength(0);
+    });
+    (0, vitest_1.it)('asigna proofId automáticamente cuando el trace no trae id', () => {
+        const p1 = trace('X', [
+            ['MP', ['P->P', 'P'], 'P', 0],
+            ['axiom', [], 'P->P', 1],
+            ['axiom', [], 'P', 1],
+        ]);
+        const p2 = trace('Y', [
+            ['MP', ['Q->Q', 'Q'], 'Q', 0],
+            ['axiom', [], 'Q->Q', 1],
+            ['axiom', [], 'Q', 1],
+        ]);
+        const groups = (0, extractor_1.extractAuxiliaryLemmas)([p1, p2]);
+        const allIds = new Set();
+        for (const g of groups)
+            for (const m of g.members)
+                allIds.add(m.proofId);
+        (0, vitest_1.expect)(allIds.has('proof-0')).toBe(true);
+        (0, vitest_1.expect)(allIds.has('proof-1')).toBe(true);
+    });
+    (0, vitest_1.it)('respeta proofId explícito cuando se provee', () => {
+        const p1 = {
+            id: 'my-proof-A',
+            ...trace('X', [
+                ['MP', ['P->P', 'P'], 'P', 0],
+                ['axiom', [], 'P->P', 1],
+                ['axiom', [], 'P', 1],
+            ]),
+        };
+        const p2 = {
+            id: 'my-proof-B',
+            ...trace('Y', [
+                ['MP', ['Q->Q', 'Q'], 'Q', 0],
+                ['axiom', [], 'Q->Q', 1],
+                ['axiom', [], 'Q', 1],
+            ]),
+        };
+        const groups = (0, extractor_1.extractAuxiliaryLemmas)([p1, p2]);
+        const allIds = new Set();
+        for (const g of groups)
+            for (const m of g.members)
+                allIds.add(m.proofId);
+        (0, vitest_1.expect)(allIds.has('my-proof-A')).toBe(true);
+        (0, vitest_1.expect)(allIds.has('my-proof-B')).toBe(true);
+    });
+});
+//# sourceMappingURL=extractor.test.js.map

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

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

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

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

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

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

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

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const generalizer_1 = require("../generalizer");
+(0, vitest_1.describe)('generalizeFormulas', () => {
+    (0, vitest_1.it)('para 0 instancias devuelve string vacío', () => {
+        (0, vitest_1.expect)((0, generalizer_1.generalizeFormulas)([])).toEqual({
+            statement: '',
+            abstractionLevel: 0,
+            nonTrivial: false,
+        });
+    });
+    (0, vitest_1.it)('para 1 instancia devuelve el original sin abstracción', () => {
+        const r = (0, generalizer_1.generalizeFormulas)(['P -> P']);
+        (0, vitest_1.expect)(r.statement).toBe('P -> P');
+        (0, vitest_1.expect)(r.abstractionLevel).toBe(0);
+        (0, vitest_1.expect)(r.nonTrivial).toBe(false);
+    });
+    (0, vitest_1.it)('P->P y Q->Q producen ?0 -> ?0', () => {
+        const r = (0, generalizer_1.generalizeFormulas)(['P -> P', 'Q -> Q']);
+        (0, vitest_1.expect)(r.abstractionLevel).toBe(1);
+        (0, vitest_1.expect)(r.nonTrivial).toBe(true);
+        (0, vitest_1.expect)(r.statement).toContain('->');
+        // Debería contener el mismo placeholder dos veces (reflexividad).
+        const matches = r.statement.match(/\?0/g);
+        (0, vitest_1.expect)(matches?.length).toBe(2);
+    });
+    (0, vitest_1.it)('P->Q y R->S producen ?0 -> ?1', () => {
+        const r = (0, generalizer_1.generalizeFormulas)(['P -> Q', 'R -> S']);
+        (0, vitest_1.expect)(r.abstractionLevel).toBe(2);
+        (0, vitest_1.expect)(r.nonTrivial).toBe(true);
+        (0, vitest_1.expect)(r.statement).toMatch(/\?0/);
+        (0, vitest_1.expect)(r.statement).toMatch(/\?1/);
+    });
+    (0, vitest_1.it)('instancias idénticas no introducen abstracción', () => {
+        const r = (0, generalizer_1.generalizeFormulas)(['P -> P', 'P -> P']);
+        (0, vitest_1.expect)(r.abstractionLevel).toBe(0);
+        (0, vitest_1.expect)(r.nonTrivial).toBe(false);
+    });
+    (0, vitest_1.it)('desacuerdos en operadores no son generalizables (fallback al literal)', () => {
+        const r = (0, generalizer_1.generalizeFormulas)(['P and Q', 'P or Q']);
+        (0, vitest_1.expect)(r.nonTrivial).toBe(false);
+        (0, vitest_1.expect)(r.statement).toBe('P and Q');
+    });
+    (0, vitest_1.it)('arrays de tokens de distinta longitud caen al primer literal', () => {
+        const r = (0, generalizer_1.generalizeFormulas)(['P', 'P -> P']);
+        (0, vitest_1.expect)(r.nonTrivial).toBe(false);
+        (0, vitest_1.expect)(r.statement).toBe('P');
+    });
+    (0, vitest_1.it)('mantiene operadores como tokens literales en el patrón', () => {
+        const r = (0, generalizer_1.generalizeFormulas)(['P -> Q', 'A -> B']);
+        (0, vitest_1.expect)(r.statement).toContain('->');
+    });
+});
+(0, vitest_1.describe)('generalizeLemma', () => {
+    (0, vitest_1.it)('respeta maxAbstractionLevel', () => {
+        const r = (0, generalizer_1.generalizeLemma)(['f(a, b, c)', 'f(x, y, z)'], { maxAbstractionLevel: 2 });
+        // Necesitaríamos 3 fresh vars; con cap = 2 cae al literal.
+        (0, vitest_1.expect)(r.abstractionLevel).toBe(0);
+        (0, vitest_1.expect)(r.statement).toBe('f(a, b, c)');
+    });
+    (0, vitest_1.it)('preserveSemantic = true no rechaza generalizaciones válidas', () => {
+        const r = (0, generalizer_1.generalizeLemma)(['P -> P', 'Q -> Q'], {
+            preserveSemantic: true,
+            maxAbstractionLevel: 5,
+        });
+        (0, vitest_1.expect)(r.nonTrivial).toBe(true);
+    });
+    (0, vitest_1.it)('opciones por defecto producen abstracción si es no-trivial', () => {
+        const r = (0, generalizer_1.generalizeLemma)(['P -> P', 'Q -> Q']);
+        (0, vitest_1.expect)(r.abstractionLevel).toBeGreaterThan(0);
+    });
+});
+(0, vitest_1.describe)('generalizeTerms', () => {
+    (0, vitest_1.it)('para 0 terms devuelve vacío', () => {
+        (0, vitest_1.expect)((0, generalizer_1.generalizeTerms)([])).toEqual({
+            statement: '',
+            abstractionLevel: 0,
+            nonTrivial: false,
+        });
+    });
+    (0, vitest_1.it)('para 1 term devuelve el original sin abstracción', () => {
+        const t = { kind: 'const', name: 'a' };
+        const r = (0, generalizer_1.generalizeTerms)([t]);
+        (0, vitest_1.expect)(r.statement).toBe('a');
+        (0, vitest_1.expect)(r.abstractionLevel).toBe(0);
+    });
+    (0, vitest_1.it)('lgg de p(a) y p(b) introduce variable fresca', () => {
+        const t1 = { kind: 'func', name: 'p', args: [{ kind: 'const', name: 'a' }] };
+        const t2 = { kind: 'func', name: 'p', args: [{ kind: 'const', name: 'b' }] };
+        const r = (0, generalizer_1.generalizeTerms)([t1, t2]);
+        (0, vitest_1.expect)(r.abstractionLevel).toBe(1);
+        (0, vitest_1.expect)(r.statement).toMatch(/^p\(/);
+    });
+    (0, vitest_1.it)('lgg de términos idénticos no introduce abstracción', () => {
+        const t1 = { kind: 'const', name: 'a' };
+        const t2 = { kind: 'const', name: 'a' };
+        const r = (0, generalizer_1.generalizeTerms)([t1, t2]);
+        (0, vitest_1.expect)(r.abstractionLevel).toBe(0);
+    });
+    (0, vitest_1.it)('lgg de p(a,a) y p(b,b) reusa la misma fresh var', () => {
+        const t1 = {
+            kind: 'func',
+            name: 'p',
+            args: [
+                { kind: 'const', name: 'a' },
+                { kind: 'const', name: 'a' },
+            ],
+        };
+        const t2 = {
+            kind: 'func',
+            name: 'p',
+            args: [
+                { kind: 'const', name: 'b' },
+                { kind: 'const', name: 'b' },
+            ],
+        };
+        const r = (0, generalizer_1.generalizeTerms)([t1, t2]);
+        // Idealmente abstractionLevel = 1 (una sola fresh var reusada).
+        (0, vitest_1.expect)(r.abstractionLevel).toBe(1);
+    });
+});
+//# sourceMappingURL=generalizer.test.js.map