@stevenvo780/st-lang 4.2.0 → 4.3.0

package/dist/runtime/fca/lattice.js

@@ -0,0 +1,86 @@
+"use strict";
+// ============================================================
+// FCA — diagrama de Hasse del concept lattice.
+// ============================================================
+// Para un conjunto B(K) de conceptos ordenado por inclusión de extent
+//   (A1, B1) ≤ (A2, B2)  ⇔  A1 ⊆ A2
+// la relación de cobertura es:
+//   c ≺ p  sii  c < p  y  no existe q con c < q < p.
+//
+// El "diagrama de Hasse" representa B(K) como un DAG con sólo las aristas
+// de cobertura. Implementación O(|B(K)|² · |M|):
+//   1. Por cada par (i, j) con i ≠ j, marcar i < j  ⇔  extent_i ⊊ extent_j.
+//   2. Para cada arista i < j, ver si existe k con i < k < j; si no,
+//      es cobertura.
+//
+// Para retículos de hasta unos pocos miles de conceptos esto es práctico;
+// para tamaños mayores conviene un algoritmo dedicado (e.g. Lindig).
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lattice = lattice;
+function isSubset(a, b) {
+    if (a.size > b.size)
+        return false;
+    for (const x of a)
+        if (!b.has(x))
+            return false;
+    return true;
+}
+function isStrictSubset(a, b) {
+    return a.size < b.size && isSubset(a, b);
+}
+/**
+ * Computa el diagrama de Hasse del concept lattice como lista de aristas
+ * de cobertura `[child, parent]` (índices en `concepts`).
+ *
+ * La orientación es de "específico" a "general":
+ *   `[i, j]` significa `extent_i ⊊ extent_j` y la inclusión es inmediata.
+ */
+function lattice(concepts) {
+    const n = concepts.length;
+    // Pre-computar la matriz <. lt[i][j] = true ⇔ extent_i ⊊ extent_j.
+    const lt = Array.from({ length: n }, () => new Array(n).fill(false));
+    for (let i = 0; i < n; i++) {
+        const ci = concepts[i];
+        if (!ci)
+            continue;
+        for (let j = 0; j < n; j++) {
+            if (i === j)
+                continue;
+            const cj = concepts[j];
+            if (!cj)
+                continue;
+            if (isStrictSubset(ci.extent, cj.extent)) {
+                const row = lt[i];
+                if (row)
+                    row[j] = true;
+            }
+        }
+    }
+    const edges = [];
+    for (let i = 0; i < n; i++) {
+        const row = lt[i];
+        if (!row)
+            continue;
+        for (let j = 0; j < n; j++) {
+            if (!row[j])
+                continue;
+            // ¿existe k con i < k < j?  Si sí, (i,j) NO es cobertura.
+            let coversImmediately = true;
+            for (let k = 0; k < n; k++) {
+                if (k === i || k === j)
+                    continue;
+                const rk = lt[i];
+                const rkj = lt[k];
+                if (rk && rkj && rk[k] && rkj[j]) {
+                    coversImmediately = false;
+                    break;
+                }
+            }
+            if (coversImmediately)
+                edges.push([i, j]);
+        }
+    }
+    return { edges };
+}
+//# sourceMappingURL=lattice.js.map

package/dist/runtime/fca/lattice.js.map

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

package/dist/runtime/fca/next-closure.d.ts

@@ -0,0 +1,12 @@
+import type { FormalConcept, FormalContext } from './types';
+/**
+ * Enumera todos los conceptos formales de `ctx` mediante Next Closure.
+ *
+ * Garantías:
+ *  - Cada concepto aparece exactamente una vez.
+ *  - El orden de salida es lectic sobre intents (creciente).
+ *  - Incluye el Top concept (G, G') y el Bottom concept (M', M) cuando
+ *    existen como cerrados (siempre existen).
+ */
+export declare function allConcepts(ctx: FormalContext): FormalConcept[];
+//# sourceMappingURL=next-closure.d.ts.map

package/dist/runtime/fca/next-closure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"next-closure.d.ts","sourceRoot":"","sources":["../../../src/runtime/fca/next-closure.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAoD5D;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,aAAa,GAAG,aAAa,EAAE,CAiB/D"}

package/dist/runtime/fca/next-closure.js

@@ -0,0 +1,99 @@
+"use strict";
+// ============================================================
+// FCA — Next Closure algorithm (Ganter, 1984).
+// ============================================================
+// Enumera todos los conjuntos cerrados de un operador de clausura
+// (aquí, la clausura de intents B → B'') en orden lexicográfico
+// respecto a un orden total fijado sobre M.
+//
+// Idea clave:
+//   1. Fijamos M = {m_0, m_1, ..., m_{n-1}} con un orden total.
+//   2. Para un conjunto cerrado B, calculamos el "siguiente" cerrado:
+//      para i desde n-1 hasta 0:
+//        - si m_i ∈ B, sáltalo;
+//        - sea C = closure( (B ∩ {m_0,...,m_{i-1}}) ∪ {m_i} ).
+//        - si C \ B no contiene ningún m_j con j < i, devolver C.
+//      Si ninguno funciona, terminamos.
+//   3. Empezamos por closure(∅) (que es M', el intent del Top concept
+//      en su forma de atributos comunes a todos los objetos) y
+//      enumeramos sucesores hasta agotar.
+//
+// La complejidad es O(|B(K)| · |M|² · |G|) en peor caso, pero amortizado
+// es excelente para contextos densos pequeños y medianos. La salida está
+// libre de duplicados por construcción (cada cerrado se visita una sola
+// vez gracias al test "C \ B no contiene m_j para j < i").
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allConcepts = allConcepts;
+const context_1 = require("./context");
+/**
+ * Compara dos subconjuntos de M en el orden "lectic" de Ganter, definido
+ * sobre la indexación posicional de `order`. NO usado externamente pero
+ * documentado: A <_i B ⇔ m_i ∈ B \ A y A ∩ {m_0,..,m_{i-1}} = B ∩ {m_0,..,m_{i-1}}.
+ *
+ * La función de sucesión usa una variante eficiente que no necesita
+ * comparar pares: solo verifica la condición de "no hay m_j más pequeño
+ * en la diferencia".
+ */
+/**
+ * Devuelve el siguiente cerrado en orden lectic, o `null` si `current` ya
+ * es el último (closure(M) = M).
+ */
+function nextClosure(ctx, order, current) {
+    for (let i = order.length - 1; i >= 0; i--) {
+        const mi = order[i];
+        if (mi === undefined)
+            continue;
+        if (current.has(mi))
+            continue;
+        // B^+ = (B ∩ {m_0,..,m_{i-1}}) ∪ {m_i}
+        const seed = new Set();
+        for (let j = 0; j < i; j++) {
+            const mj = order[j];
+            if (mj !== undefined && current.has(mj))
+                seed.add(mj);
+        }
+        seed.add(mi);
+        const closed = (0, context_1.closeIntent)(ctx, seed);
+        // Test lectic: el cerrado no debe contener m_j con j < i que no estuviera
+        // ya en current. Equivale a: (closed \ current) ∩ {m_0,...,m_{i-1}} = ∅.
+        let valid = true;
+        for (let j = 0; j < i; j++) {
+            const mj = order[j];
+            if (mj === undefined)
+                continue;
+            if (closed.has(mj) && !current.has(mj)) {
+                valid = false;
+                break;
+            }
+        }
+        if (valid)
+            return closed;
+    }
+    return null;
+}
+/**
+ * Enumera todos los conceptos formales de `ctx` mediante Next Closure.
+ *
+ * Garantías:
+ *  - Cada concepto aparece exactamente una vez.
+ *  - El orden de salida es lectic sobre intents (creciente).
+ *  - Incluye el Top concept (G, G') y el Bottom concept (M', M) cuando
+ *    existen como cerrados (siempre existen).
+ */
+function allConcepts(ctx) {
+    const order = [...ctx.attributes];
+    const concepts = [];
+    // Punto de arranque: clausura del conjunto vacío.
+    // ∅' = G (todos los objetos satisfacen trivialmente "ningún atributo"),
+    // luego (∅')' = G' = atributos comunes a todos los objetos.
+    let current = (0, context_1.closeIntent)(ctx, new Set());
+    while (current !== null) {
+        const intent = current;
+        const extent = (0, context_1.derivativeObjects)(ctx, intent);
+        concepts.push({ extent, intent });
+        current = nextClosure(ctx, order, current);
+    }
+    return concepts;
+}
+//# sourceMappingURL=next-closure.js.map

package/dist/runtime/fca/next-closure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"next-closure.js","sourceRoot":"","sources":["../../../src/runtime/fca/next-closure.ts"],"names":[],"mappings":"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"}

package/dist/runtime/fca/types.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Contexto formal K = (G, M, I).
+ *  - `objects`    G como lista finita ordenada.
+ *  - `attributes` M como lista finita ordenada.
+ *  - `incidence`  representación canónica como conjunto de pares
+ *                 codificados "objeto|atributo" para test O(1).
+ */
+export interface FormalContext {
+    objects: string[];
+    attributes: string[];
+    incidence: Set<string>;
+}
+/**
+ * Concepto formal (A, B) con A = extent, B = intent.
+ * Invariante: A' = B y B' = A (verificable con `isConcept`).
+ */
+export interface FormalConcept {
+    extent: Set<string>;
+    intent: Set<string>;
+}
+/**
+ * Diagrama de Hasse del concept lattice como lista de aristas de cobertura.
+ * `edges[i] = [child, parent]` significa que el concepto `child` está cubierto
+ * inmediatamente por `parent` (no hay concepto intermedio estricto).
+ * Los índices son posiciones en el array de conceptos devuelto por
+ * `allConcepts`.
+ */
+export interface HasseLattice {
+    edges: Array<[number, number]>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/runtime/fca/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/runtime/fca/types.ts"],"names":[],"mappings":"AA4BA;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACxB;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACpB,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACrB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAChC"}

package/dist/runtime/fca/types.js

@@ -0,0 +1,30 @@
+"use strict";
+// ============================================================
+// Formal Concept Analysis (FCA) — tipos públicos
+// ============================================================
+// Marco matemático de Wille (1982) para extraer una jerarquía conceptual
+// a partir de una relación binaria objeto-atributo.
+//
+// Contexto formal:
+//   K = (G, M, I)
+//     G  conjunto finito de "objetos"
+//     M  conjunto finito de "atributos"
+//     I ⊆ G × M  relación de incidencia ("el objeto g tiene el atributo m")
+//
+// Operadores de derivación (polares de Galois):
+//   A' = { m ∈ M | ∀ g ∈ A. (g, m) ∈ I }     (atributos comunes a A ⊆ G)
+//   B' = { g ∈ G | ∀ m ∈ B. (g, m) ∈ I }     (objetos que poseen todo B ⊆ M)
+//
+// Un concepto formal es un par (A, B) con A ⊆ G, B ⊆ M tal que
+//   A' = B  y  B' = A
+// equivalentemente:  A = A''  y  B = B''  (clausura).
+//
+// El conjunto B(K) de todos los conceptos, ordenado por
+//   (A1, B1) ≤ (A2, B2) ⇔ A1 ⊆ A2  ( ⇔ B2 ⊆ B1 )
+// forma un retículo completo (lattice), el "concept lattice".
+//
+// Top:     (G, G')   — todos los objetos, atributos comunes.
+// Bottom:  (M', M)   — atributos en todos, en general ∅ objetos.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/runtime/fca/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/runtime/fca/types.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,iDAAiD;AACjD,+DAA+D;AAC/D,yEAAyE;AACzE,oDAAoD;AACpD,EAAE;AACF,mBAAmB;AACnB,kBAAkB;AAClB,sCAAsC;AACtC,wCAAwC;AACxC,4EAA4E;AAC5E,EAAE;AACF,gDAAgD;AAChD,yEAAyE;AACzE,6EAA6E;AAC7E,EAAE;AACF,+DAA+D;AAC/D,sBAAsB;AACtB,sDAAsD;AACtD,EAAE;AACF,wDAAwD;AACxD,iDAAiD;AACjD,8DAA8D;AAC9D,EAAE;AACF,6DAA6D;AAC7D,iEAAiE;AACjE,+DAA+D"}

package/dist/runtime/proof-minify/index.d.ts

@@ -0,0 +1,3 @@
+export { minifyProof, compactModusPonensChain, removeUnusedSubproofs, countNodes, depthOf, } from './minify';
+export type { GenericProofNode, MinifyOptions, MinifyResult, MinifyRule } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/proof-minify/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/proof-minify/index.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,WAAW,EACX,uBAAuB,EACvB,qBAAqB,EACrB,UAAU,EACV,OAAO,GACR,MAAM,UAAU,CAAC;AAElB,YAAY,EAAE,gBAAgB,EAAE,aAAa,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC"}

package/dist/runtime/proof-minify/index.js

@@ -0,0 +1,13 @@
+"use strict";
+// ============================================================
+// ST Proof Minification — Barrel
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.depthOf = exports.countNodes = exports.removeUnusedSubproofs = exports.compactModusPonensChain = exports.minifyProof = void 0;
+var minify_1 = require("./minify");
+Object.defineProperty(exports, "minifyProof", { enumerable: true, get: function () { return minify_1.minifyProof; } });
+Object.defineProperty(exports, "compactModusPonensChain", { enumerable: true, get: function () { return minify_1.compactModusPonensChain; } });
+Object.defineProperty(exports, "removeUnusedSubproofs", { enumerable: true, get: function () { return minify_1.removeUnusedSubproofs; } });
+Object.defineProperty(exports, "countNodes", { enumerable: true, get: function () { return minify_1.countNodes; } });
+Object.defineProperty(exports, "depthOf", { enumerable: true, get: function () { return minify_1.depthOf; } });
+//# sourceMappingURL=index.js.map

package/dist/runtime/proof-minify/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime/proof-minify/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,iCAAiC;AACjC,+DAA+D;;;AAE/D,mCAMkB;AALhB,qGAAA,WAAW,OAAA;AACX,iHAAA,uBAAuB,OAAA;AACvB,+GAAA,qBAAqB,OAAA;AACrB,oGAAA,UAAU,OAAA;AACV,iGAAA,OAAO,OAAA"}

package/dist/runtime/proof-minify/minify.d.ts

@@ -0,0 +1,13 @@
+import type { GenericProofNode, MinifyOptions, MinifyResult } from './types';
+/** Cuenta los nodos de un árbol (raíz incluida). */
+export declare function countNodes(n: GenericProofNode): number;
+/** Profundidad máxima (raíz = 0). */
+export declare function depthOf(n: GenericProofNode): number;
+export declare function compactModusPonensChain(proof: GenericProofNode): GenericProofNode;
+export declare function removeUnusedSubproofs(proof: GenericProofNode): GenericProofNode;
+/**
+ * Minifica un árbol de pruebas iterando las reglas hasta punto fijo
+ * o agotar `maxIterations`.
+ */
+export declare function minifyProof(proof: GenericProofNode, opts?: MinifyOptions): MinifyResult;
+//# sourceMappingURL=minify.d.ts.map

package/dist/runtime/proof-minify/minify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minify.d.ts","sourceRoot":"","sources":["../../../src/runtime/proof-minify/minify.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,YAAY,EAAc,MAAM,SAAS,CAAC;AA2GzF,oDAAoD;AACpD,wBAAgB,UAAU,CAAC,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAItD;AAED,qCAAqC;AACrC,wBAAgB,OAAO,CAAC,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAQnD;AAqGD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,gBAAgB,GAAG,gBAAgB,CAwBjF;AAgJD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,gBAAgB,GAAG,gBAAgB,CAG/E;AA8GD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,gBAAgB,EAAE,IAAI,GAAE,aAAkB,GAAG,YAAY,CAuC3F"}