@stevenvo780/st-lang 4.14.1 → 4.15.0

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stevenvo780/st-lang",
-  "version": "4.14.1",
+  "version": "4.15.0",
   "description": "ST — Lenguaje ejecutable con nucleo logico y capa textual. Motor multi-perfil (11 lógicas), derivaciones, tablas de verdad, contramodelos, aliases modales, Belnap 4-valores y capa textual para formalización de documentos.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -24,6 +24,31 @@
       "types": "./dist/protocol/handler.d.ts",
       "require": "./dist/protocol/handler.js",
       "default": "./dist/protocol/handler.js"
+    },
+    "./reasoning/proof-mining": {
+      "types": "./dist/reasoning/proof-mining/index.d.ts",
+      "require": "./dist/reasoning/proof-mining/index.js",
+      "default": "./dist/reasoning/proof-mining/index.js"
+    },
+    "./format/stnb": {
+      "types": "./dist/format/stnb/index.d.ts",
+      "require": "./dist/format/stnb/index.js",
+      "default": "./dist/format/stnb/index.js"
+    },
+    "./logic/profiles/dl-hybrid": {
+      "types": "./dist/logic/profiles/dl-hybrid/index.d.ts",
+      "require": "./dist/logic/profiles/dl-hybrid/index.js",
+      "default": "./dist/logic/profiles/dl-hybrid/index.js"
+    },
+    "./reasoning/dl-hybrid": {
+      "types": "./dist/reasoning/dl-hybrid/index.d.ts",
+      "require": "./dist/reasoning/dl-hybrid/index.js",
+      "default": "./dist/reasoning/dl-hybrid/index.js"
+    },
+    "./reasoning/lemma-rag": {
+      "types": "./dist/reasoning/lemma-rag/index.d.ts",
+      "require": "./dist/reasoning/lemma-rag/index.js",
+      "default": "./dist/reasoning/lemma-rag/index.js"
     }
   },
   "bin": {