@stevenvo780/st-lang 4.1.0 → 4.3.0

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

@@ -0,0 +1,46 @@
+import type { FormalContext } from './types';
+/**
+ * Construye un contexto formal a partir de listas de objetos, atributos y
+ * la lista bruta de incidencias.
+ *
+ * Valida:
+ *  - Los identificadores no pueden contener el separador '|'.
+ *  - No se admiten objetos o atributos duplicados.
+ *  - Cada incidencia [g, m] debe referirse a objetos/atributos declarados.
+ */
+export declare function createContext(objects: string[], attributes: string[], incidence: Array<[string, string]>): FormalContext;
+/**
+ * Indica si el objeto `g` tiene el atributo `m` en el contexto.
+ * O(1) gracias a la representación como Set de pares codificados.
+ */
+export declare function hasIncidence(ctx: FormalContext, g: string, m: string): boolean;
+/**
+ * Operador polar B → B'  (atributos → objetos).
+ * Devuelve el conjunto de objetos que poseen TODOS los atributos de `attrs`.
+ * Si `attrs` es vacío, el resultado es G (convención: ∀ trivialmente cierto).
+ */
+export declare function derivativeObjects(ctx: FormalContext, attrs: Set<string>): Set<string>;
+/**
+ * Operador polar A → A'  (objetos → atributos).
+ * Devuelve los atributos compartidos por TODOS los objetos de `objs`.
+ * Si `objs` es vacío, el resultado es M.
+ */
+export declare function derivativeAttributes(ctx: FormalContext, objs: Set<string>): Set<string>;
+/**
+ * Verifica si (extent, intent) es un concepto formal en `ctx`:
+ *   extent' = intent  y  intent' = extent.
+ *
+ * Equivale a verificar la doble clausura, pero se computa directo desde la
+ * relación de incidencia, sin acumular intermedios.
+ */
+export declare function isConcept(ctx: FormalContext, extent: Set<string>, intent: Set<string>): boolean;
+/**
+ * Clausura de Galois sobre intents:  B → B'' = (B')'.
+ * Idempotente: closeIntent(closeIntent(B)) = closeIntent(B).
+ */
+export declare function closeIntent(ctx: FormalContext, intent: Set<string>): Set<string>;
+/**
+ * Clausura sobre extents:  A → A'' = (A')'.
+ */
+export declare function closeExtent(ctx: FormalContext, extent: Set<string>): Set<string>;
+//# sourceMappingURL=context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/runtime/fca/context.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAQ7C;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EAAE,EACjB,UAAU,EAAE,MAAM,EAAE,EACpB,SAAS,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GACjC,aAAa,CAsCf;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,aAAa,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAE9E;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,aAAa,EAAE,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAarF;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,aAAa,EAAE,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAavF;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,OAAO,CAI/F;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAEhF;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAEhF"}

package/dist/runtime/fca/context.js

@@ -0,0 +1,155 @@
+"use strict";
+// ============================================================
+// FCA — construcción del contexto y operadores polares de Galois.
+// ============================================================
+// Aquí viven las primitivas de bajo nivel: construir K = (G, M, I) y
+// computar las dos derivaciones A → A' y B → B' que sustentan toda la
+// teoría (definición de concepto, clausura, implicación).
+//
+// Notación interna: codificamos un par (g, m) ∈ I como la cadena
+// "g|m". El delimitador '|' es seguro porque obligamos que ningún
+// identificador lo contenga (createContext lo valida); de lo contrario
+// usaríamos un Map<string, Set<string>>.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContext = createContext;
+exports.hasIncidence = hasIncidence;
+exports.derivativeObjects = derivativeObjects;
+exports.derivativeAttributes = derivativeAttributes;
+exports.isConcept = isConcept;
+exports.closeIntent = closeIntent;
+exports.closeExtent = closeExtent;
+const SEP = '|';
+function encode(obj, attr) {
+    return `${obj}${SEP}${attr}`;
+}
+/**
+ * Construye un contexto formal a partir de listas de objetos, atributos y
+ * la lista bruta de incidencias.
+ *
+ * Valida:
+ *  - Los identificadores no pueden contener el separador '|'.
+ *  - No se admiten objetos o atributos duplicados.
+ *  - Cada incidencia [g, m] debe referirse a objetos/atributos declarados.
+ */
+function createContext(objects, attributes, incidence) {
+    const objSet = new Set();
+    for (const o of objects) {
+        if (o.includes(SEP)) {
+            throw new Error(`createContext: objeto "${o}" contiene el separador reservado "${SEP}"`);
+        }
+        if (objSet.has(o)) {
+            throw new Error(`createContext: objeto duplicado "${o}"`);
+        }
+        objSet.add(o);
+    }
+    const attrSet = new Set();
+    for (const a of attributes) {
+        if (a.includes(SEP)) {
+            throw new Error(`createContext: atributo "${a}" contiene el separador reservado "${SEP}"`);
+        }
+        if (attrSet.has(a)) {
+            throw new Error(`createContext: atributo duplicado "${a}"`);
+        }
+        attrSet.add(a);
+    }
+    const inc = new Set();
+    for (const [g, m] of incidence) {
+        if (!objSet.has(g)) {
+            throw new Error(`createContext: incidencia refiere objeto desconocido "${g}"`);
+        }
+        if (!attrSet.has(m)) {
+            throw new Error(`createContext: incidencia refiere atributo desconocido "${m}"`);
+        }
+        inc.add(encode(g, m));
+    }
+    return {
+        objects: [...objects],
+        attributes: [...attributes],
+        incidence: inc,
+    };
+}
+/**
+ * Indica si el objeto `g` tiene el atributo `m` en el contexto.
+ * O(1) gracias a la representación como Set de pares codificados.
+ */
+function hasIncidence(ctx, g, m) {
+    return ctx.incidence.has(encode(g, m));
+}
+/**
+ * Operador polar B → B'  (atributos → objetos).
+ * Devuelve el conjunto de objetos que poseen TODOS los atributos de `attrs`.
+ * Si `attrs` es vacío, el resultado es G (convención: ∀ trivialmente cierto).
+ */
+function derivativeObjects(ctx, attrs) {
+    const out = new Set();
+    for (const g of ctx.objects) {
+        let ok = true;
+        for (const m of attrs) {
+            if (!hasIncidence(ctx, g, m)) {
+                ok = false;
+                break;
+            }
+        }
+        if (ok)
+            out.add(g);
+    }
+    return out;
+}
+/**
+ * Operador polar A → A'  (objetos → atributos).
+ * Devuelve los atributos compartidos por TODOS los objetos de `objs`.
+ * Si `objs` es vacío, el resultado es M.
+ */
+function derivativeAttributes(ctx, objs) {
+    const out = new Set();
+    for (const m of ctx.attributes) {
+        let ok = true;
+        for (const g of objs) {
+            if (!hasIncidence(ctx, g, m)) {
+                ok = false;
+                break;
+            }
+        }
+        if (ok)
+            out.add(m);
+    }
+    return out;
+}
+/**
+ * Verifica si (extent, intent) es un concepto formal en `ctx`:
+ *   extent' = intent  y  intent' = extent.
+ *
+ * Equivale a verificar la doble clausura, pero se computa directo desde la
+ * relación de incidencia, sin acumular intermedios.
+ */
+function isConcept(ctx, extent, intent) {
+    const intentFromExtent = derivativeAttributes(ctx, extent);
+    const extentFromIntent = derivativeObjects(ctx, intent);
+    return setsEqual(intentFromExtent, intent) && setsEqual(extentFromIntent, extent);
+}
+/**
+ * Clausura de Galois sobre intents:  B → B'' = (B')'.
+ * Idempotente: closeIntent(closeIntent(B)) = closeIntent(B).
+ */
+function closeIntent(ctx, intent) {
+    return derivativeAttributes(ctx, derivativeObjects(ctx, intent));
+}
+/**
+ * Clausura sobre extents:  A → A'' = (A')'.
+ */
+function closeExtent(ctx, extent) {
+    return derivativeObjects(ctx, derivativeAttributes(ctx, extent));
+}
+// ----------------------------------------------------------------
+// helpers
+// ----------------------------------------------------------------
+function setsEqual(a, b) {
+    if (a.size !== b.size)
+        return false;
+    for (const x of a)
+        if (!b.has(x))
+            return false;
+    return true;
+}
+//# sourceMappingURL=context.js.map

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

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

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

@@ -0,0 +1,10 @@
+import type { FormalContext } from './types';
+/**
+ * Devuelve `true` si en `ctx` la implicación `premise → conclusion` es
+ * válida: todo objeto que satisface todos los atributos de `premise`
+ * satisface también todos los de `conclusion`.
+ *
+ * Equivalencia formal:  premise → conclusion  ⇔  conclusion ⊆ premise''.
+ */
+export declare function impliesAll(ctx: FormalContext, premise: Set<string>, conclusion: Set<string>): boolean;
+//# sourceMappingURL=implications.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"implications.d.ts","sourceRoot":"","sources":["../../../src/runtime/fca/implications.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,GAAG,EAAE,aAAa,EAClB,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,EACpB,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,GACtB,OAAO,CAMT"}

package/dist/runtime/fca/implications.js

@@ -0,0 +1,33 @@
+"use strict";
+// ============================================================
+// FCA — implicaciones de atributos.
+// ============================================================
+// Una implicación P → C entre subconjuntos de atributos es válida en el
+// contexto K sii todo objeto que tiene todos los atributos de P tiene
+// también todos los atributos de C. Equivale a:
+//   P → C válida en K  ⇔  C ⊆ P''   (P'' = closeIntent(P))
+// que en términos de extents es: P' ⊆ C'.
+//
+// Esto es la base del cálculo Armstrong/Duquenne-Guigues para bases de
+// implicaciones. Aquí exponemos solo el test de validez puntual; la
+// extracción de la base canónica se deja a un sprint posterior.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.impliesAll = impliesAll;
+const context_1 = require("./context");
+/**
+ * Devuelve `true` si en `ctx` la implicación `premise → conclusion` es
+ * válida: todo objeto que satisface todos los atributos de `premise`
+ * satisface también todos los de `conclusion`.
+ *
+ * Equivalencia formal:  premise → conclusion  ⇔  conclusion ⊆ premise''.
+ */
+function impliesAll(ctx, premise, conclusion) {
+    const closure = (0, context_1.closeIntent)(ctx, premise);
+    for (const m of conclusion) {
+        if (!closure.has(m))
+            return false;
+    }
+    return true;
+}
+//# sourceMappingURL=implications.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"implications.js","sourceRoot":"","sources":["../../../src/runtime/fca/implications.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,oCAAoC;AACpC,+DAA+D;AAC/D,wEAAwE;AACxE,sEAAsE;AACtE,gDAAgD;AAChD,2DAA2D;AAC3D,0CAA0C;AAC1C,EAAE;AACF,uEAAuE;AACvE,oEAAoE;AACpE,gEAAgE;AAChE,+DAA+D;;AAY/D,gCAUC;AApBD,uCAAwC;AAGxC;;;;;;GAMG;AACH,SAAgB,UAAU,CACxB,GAAkB,EAClB,OAAoB,EACpB,UAAuB;IAEvB,MAAM,OAAO,GAAG,IAAA,qBAAW,EAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IAC1C,KAAK,MAAM,CAAC,IAAI,UAAU,EAAE,CAAC;QAC3B,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;YAAE,OAAO,KAAK,CAAC;IACpC,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

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

@@ -0,0 +1,6 @@
+export type { FormalContext, FormalConcept, HasseLattice } from './types';
+export { createContext, derivativeObjects, derivativeAttributes, isConcept, closeIntent, closeExtent, hasIncidence, } from './context';
+export { allConcepts } from './next-closure';
+export { lattice } from './lattice';
+export { impliesAll } from './implications';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/fca/index.ts"],"names":[],"mappings":"AAsBA,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC1E,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,oBAAoB,EACpB,SAAS,EACT,WAAW,EACX,WAAW,EACX,YAAY,GACb,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/runtime/fca/index.js

@@ -0,0 +1,39 @@
+"use strict";
+// ============================================================
+// ST Formal Concept Analysis — barrel público.
+// ============================================================
+// Marco matemático (Wille 1982, Ganter & Wille 1999) para extraer un
+// retículo de conceptos a partir de una relación binaria objeto-atributo.
+//
+// API mínima:
+//   createContext(G, M, I)        → FormalContext
+//   derivativeObjects(K, B)       → B'   (objetos)
+//   derivativeAttributes(K, A)    → A'   (atributos)
+//   isConcept(K, A, B)            → (A, B) ∈ B(K)?
+//   closeIntent(K, B)             → B''  (clausura Galois sobre atributos)
+//   allConcepts(K)                → todos los conceptos (Next Closure)
+//   lattice(concepts)             → diagrama de Hasse (aristas cobertura)
+//   impliesAll(K, P, C)           → ¿P → C válida en K?
+//
+// Uso típico:
+//   const K = createContext(objs, attrs, pairs);
+//   const concepts = allConcepts(K);
+//   const hasse = lattice(concepts);
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.impliesAll = exports.lattice = exports.allConcepts = exports.hasIncidence = exports.closeExtent = exports.closeIntent = exports.isConcept = exports.derivativeAttributes = exports.derivativeObjects = exports.createContext = void 0;
+var context_1 = require("./context");
+Object.defineProperty(exports, "createContext", { enumerable: true, get: function () { return context_1.createContext; } });
+Object.defineProperty(exports, "derivativeObjects", { enumerable: true, get: function () { return context_1.derivativeObjects; } });
+Object.defineProperty(exports, "derivativeAttributes", { enumerable: true, get: function () { return context_1.derivativeAttributes; } });
+Object.defineProperty(exports, "isConcept", { enumerable: true, get: function () { return context_1.isConcept; } });
+Object.defineProperty(exports, "closeIntent", { enumerable: true, get: function () { return context_1.closeIntent; } });
+Object.defineProperty(exports, "closeExtent", { enumerable: true, get: function () { return context_1.closeExtent; } });
+Object.defineProperty(exports, "hasIncidence", { enumerable: true, get: function () { return context_1.hasIncidence; } });
+var next_closure_1 = require("./next-closure");
+Object.defineProperty(exports, "allConcepts", { enumerable: true, get: function () { return next_closure_1.allConcepts; } });
+var lattice_1 = require("./lattice");
+Object.defineProperty(exports, "lattice", { enumerable: true, get: function () { return lattice_1.lattice; } });
+var implications_1 = require("./implications");
+Object.defineProperty(exports, "impliesAll", { enumerable: true, get: function () { return implications_1.impliesAll; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime/fca/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,+CAA+C;AAC/C,+DAA+D;AAC/D,qEAAqE;AACrE,0EAA0E;AAC1E,EAAE;AACF,cAAc;AACd,kDAAkD;AAClD,mDAAmD;AACnD,qDAAqD;AACrD,mDAAmD;AACnD,2EAA2E;AAC3E,uEAAuE;AACvE,0EAA0E;AAC1E,wDAAwD;AACxD,EAAE;AACF,cAAc;AACd,iDAAiD;AACjD,qCAAqC;AACrC,qCAAqC;AACrC,+DAA+D;;;AAG/D,qCAQmB;AAPjB,wGAAA,aAAa,OAAA;AACb,4GAAA,iBAAiB,OAAA;AACjB,+GAAA,oBAAoB,OAAA;AACpB,oGAAA,SAAS,OAAA;AACT,sGAAA,WAAW,OAAA;AACX,sGAAA,WAAW,OAAA;AACX,uGAAA,YAAY,OAAA;AAEd,+CAA6C;AAApC,2GAAA,WAAW,OAAA;AACpB,qCAAoC;AAA3B,kGAAA,OAAO,OAAA;AAChB,+CAA4C;AAAnC,0GAAA,UAAU,OAAA"}

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

@@ -0,0 +1,10 @@
+import type { FormalConcept, HasseLattice } from './types';
+/**
+ * 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.
+ */
+export declare function lattice(concepts: FormalConcept[]): HasseLattice;
+//# sourceMappingURL=lattice.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lattice.d.ts","sourceRoot":"","sources":["../../../src/runtime/fca/lattice.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAY3D;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,QAAQ,EAAE,aAAa,EAAE,GAAG,YAAY,CAyC/D"}

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