@stevenvo780/st-lang 4.2.0 → 4.4.0

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/markov-logic/grounding.d.ts

@@ -0,0 +1,19 @@
+import { type FOLNode } from './parser';
+import type { GroundedFormula, MLNFormula, MLNTheory, MLNWorld } from './types';
+interface PredicateMap {
+    [name: string]: string[];
+}
+/** Canonical key para un ground atom: "Pred(a1,a2,...)". */
+export declare function atomKey(predicate: string, args: string[]): string;
+/** Evalúa un nodo ya groundeado contra un mundo. */
+export declare function evaluateGround(node: FOLNode, world: MLNWorld): boolean;
+/** Renderiza un nodo groundeado a string canónico. */
+export declare function renderGround(node: FOLNode): string;
+/** Groundea una sola fórmula. */
+export declare function groundFormula(formula: MLNFormula, predMap: PredicateMap, constants: Record<string, string[]>): GroundedFormula[];
+/** Groundea TODAS las fórmulas de la teoría. */
+export declare function ground(theory: MLNTheory): GroundedFormula[];
+/** Enumera TODOS los ground atoms de la teoría (Herbrand base). */
+export declare function allGroundAtoms(theory: MLNTheory): string[];
+export {};
+//# sourceMappingURL=grounding.d.ts.map

package/dist/runtime/markov-logic/grounding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grounding.d.ts","sourceRoot":"","sources":["../../../src/runtime/markov-logic/grounding.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,KAAK,OAAO,EAAuC,MAAM,UAAU,CAAC;AAC7E,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEhF,UAAU,YAAY;IACpB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC1B;AAmFD,4DAA4D;AAC5D,wBAAgB,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAEjE;AAoBD,oDAAoD;AACpD,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAetE;AAED,sDAAsD;AACtD,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAalD;AA2CD,iCAAiC;AACjC,wBAAgB,aAAa,CAC3B,OAAO,EAAE,UAAU,EACnB,OAAO,EAAE,YAAY,EACrB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAClC,eAAe,EAAE,CAoBnB;AAED,gDAAgD;AAChD,wBAAgB,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,eAAe,EAAE,CAS3D;AAMD,mEAAmE;AACnE,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,EAAE,CA6B1D"}

package/dist/runtime/markov-logic/grounding.js

@@ -0,0 +1,252 @@
+"use strict";
+// ============================================================
+// Markov Logic — Grounding de fórmulas
+// ============================================================
+//
+// `ground(theory)` produce TODAS las instancias cerradas (sin
+// variables libres) de cada fórmula de la teoría, una por
+// combinación de constantes compatible con los tipos del
+// predicado en el que aparece la variable.
+//
+// La inferencia de tipos por variable se hace en una primera pasada
+// sobre la fórmula: por cada átomo `Pred(x, y, ...)` consultamos
+// `predicates[Pred].types` y asignamos el tipo de cada argumento a la
+// variable correspondiente. Si la misma variable aparece en dos
+// posiciones tipadas distintamente, se reporta error (typing claro
+// como pide la convención del workspace).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.atomKey = atomKey;
+exports.evaluateGround = evaluateGround;
+exports.renderGround = renderGround;
+exports.groundFormula = groundFormula;
+exports.ground = ground;
+exports.allGroundAtoms = allGroundAtoms;
+const parser_1 = require("./parser");
+function buildPredicateMap(theory) {
+    const out = {};
+    for (const p of theory.predicates) {
+        out[p.name] = p.types;
+    }
+    return out;
+}
+/** Recorre `node` y devuelve `{ variable → tipo }` inferido. */
+function inferVariableTypes(node, predMap, src) {
+    const out = {};
+    const visit = (n) => {
+        switch (n.kind) {
+            case 'atom': {
+                const types = predMap[n.predicate];
+                if (!types) {
+                    throw new Error(`Predicado "${n.predicate}" no declarado (fórmula: "${src}")`);
+                }
+                if (types.length !== n.args.length) {
+                    throw new Error(`Predicado "${n.predicate}" espera ${types.length} args, recibió ${n.args.length} (fórmula: "${src}")`);
+                }
+                for (let i = 0; i < n.args.length; i++) {
+                    const arg = n.args[i];
+                    const t = types[i];
+                    if ((0, parser_1.isVariable)(arg)) {
+                        const prev = out[arg];
+                        if (prev !== undefined && prev !== t) {
+                            throw new Error(`Variable "${arg}" usada con tipos distintos: "${prev}" vs "${t}" en "${src}"`);
+                        }
+                        out[arg] = t;
+                    }
+                }
+                return;
+            }
+            case 'not':
+                visit(n.arg);
+                return;
+            case 'and':
+            case 'or':
+            case 'implies':
+                visit(n.left);
+                visit(n.right);
+                return;
+        }
+    };
+    visit(node);
+    return out;
+}
+/** Sustituye variables → constantes y devuelve nuevo nodo. */
+function substitute(node, sub) {
+    switch (node.kind) {
+        case 'atom':
+            return {
+                kind: 'atom',
+                predicate: node.predicate,
+                args: node.args.map((a) => ((0, parser_1.isVariable)(a) && sub[a] !== undefined ? sub[a] : a)),
+            };
+        case 'not':
+            return { kind: 'not', arg: substitute(node.arg, sub) };
+        case 'and':
+            return { kind: 'and', left: substitute(node.left, sub), right: substitute(node.right, sub) };
+        case 'or':
+            return { kind: 'or', left: substitute(node.left, sub), right: substitute(node.right, sub) };
+        case 'implies':
+            return {
+                kind: 'implies',
+                left: substitute(node.left, sub),
+                right: substitute(node.right, sub),
+            };
+    }
+}
+/** Canonical key para un ground atom: "Pred(a1,a2,...)". */
+function atomKey(predicate, args) {
+    return `${predicate}(${args.join(',')})`;
+}
+/** Recopila los atom keys que aparecen en `node`. */
+function collectAtoms(node, acc) {
+    switch (node.kind) {
+        case 'atom':
+            acc.add(atomKey(node.predicate, node.args));
+            return;
+        case 'not':
+            collectAtoms(node.arg, acc);
+            return;
+        case 'and':
+        case 'or':
+        case 'implies':
+            collectAtoms(node.left, acc);
+            collectAtoms(node.right, acc);
+            return;
+    }
+}
+/** Evalúa un nodo ya groundeado contra un mundo. */
+function evaluateGround(node, world) {
+    switch (node.kind) {
+        case 'atom': {
+            const key = atomKey(node.predicate, node.args);
+            return world.groundAtoms[key] === true;
+        }
+        case 'not':
+            return !evaluateGround(node.arg, world);
+        case 'and':
+            return evaluateGround(node.left, world) && evaluateGround(node.right, world);
+        case 'or':
+            return evaluateGround(node.left, world) || evaluateGround(node.right, world);
+        case 'implies':
+            return !evaluateGround(node.left, world) || evaluateGround(node.right, world);
+    }
+}
+/** Renderiza un nodo groundeado a string canónico. */
+function renderGround(node) {
+    switch (node.kind) {
+        case 'atom':
+            return atomKey(node.predicate, node.args);
+        case 'not':
+            return `¬${renderGround(node.arg)}`;
+        case 'and':
+            return `(${renderGround(node.left)} ∧ ${renderGround(node.right)})`;
+        case 'or':
+            return `(${renderGround(node.left)} ∨ ${renderGround(node.right)})`;
+        case 'implies':
+            return `(${renderGround(node.left)} → ${renderGround(node.right)})`;
+    }
+}
+/** Producto cartesiano de los dominios de cada variable. */
+function cartesian(vars, varTypes, constants, src) {
+    if (vars.length === 0)
+        return [{}];
+    // build domain per var
+    const domains = vars.map((v) => {
+        const t = varTypes[v];
+        if (!t) {
+            throw new Error(`No pude inferir el tipo de la variable "${v}" en "${src}"`);
+        }
+        const dom = constants[t];
+        if (!dom) {
+            throw new Error(`Tipo "${t}" no tiene constantes declaradas (fórmula: "${src}")`);
+        }
+        return dom;
+    });
+    const out = [];
+    const buf = new Array(vars.length).fill('');
+    const rec = (i) => {
+        if (i === vars.length) {
+            const sub = {};
+            for (let j = 0; j < vars.length; j++) {
+                sub[vars[j]] = buf[j];
+            }
+            out.push(sub);
+            return;
+        }
+        const dom = domains[i];
+        for (const c of dom) {
+            buf[i] = c;
+            rec(i + 1);
+        }
+    };
+    rec(0);
+    return out;
+}
+/** Groundea una sola fórmula. */
+function groundFormula(formula, predMap, constants) {
+    const ast = (0, parser_1.parseFOL)(formula.formula);
+    const varTypes = inferVariableTypes(ast, predMap, formula.formula);
+    const vars = (0, parser_1.freeVariables)(ast);
+    const subs = cartesian(vars, varTypes, constants, formula.formula);
+    const out = [];
+    for (const sub of subs) {
+        const ground = substitute(ast, sub);
+        const atomSet = new Set();
+        collectAtoms(ground, atomSet);
+        const atoms = Array.from(atomSet);
+        out.push({
+            groundFormula: renderGround(ground),
+            weight: formula.weight,
+            satisfied: (w) => evaluateGround(ground, w),
+            violations: (w) => (evaluateGround(ground, w) ? 0 : 1),
+            atoms,
+        });
+    }
+    return out;
+}
+/** Groundea TODAS las fórmulas de la teoría. */
+function ground(theory) {
+    const predMap = buildPredicateMap(theory);
+    const out = [];
+    for (const f of theory.formulas) {
+        for (const g of groundFormula(f, predMap, constantsOf(theory))) {
+            out.push(g);
+        }
+    }
+    return out;
+}
+function constantsOf(theory) {
+    return theory.constants;
+}
+/** Enumera TODOS los ground atoms de la teoría (Herbrand base). */
+function allGroundAtoms(theory) {
+    const out = [];
+    for (const p of theory.predicates) {
+        const arity = p.types.length;
+        if (arity === 0) {
+            out.push(atomKey(p.name, []));
+            continue;
+        }
+        // cartesian over each arg's type
+        const domains = p.types.map((t) => {
+            const d = theory.constants[t];
+            if (!d)
+                throw new Error(`Tipo "${t}" sin constantes (predicado "${p.name}")`);
+            return d;
+        });
+        const buf = new Array(arity).fill('');
+        const rec = (i) => {
+            if (i === arity) {
+                out.push(atomKey(p.name, buf.slice()));
+                return;
+            }
+            const dom = domains[i];
+            for (const c of dom) {
+                buf[i] = c;
+                rec(i + 1);
+            }
+        };
+        rec(0);
+    }
+    return out;
+}
+//# sourceMappingURL=grounding.js.map

package/dist/runtime/markov-logic/grounding.js.map

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

package/dist/runtime/markov-logic/index.d.ts

@@ -0,0 +1,6 @@
+export type { FOLNode } from './parser';
+export { freeVariables, parseFOL } from './parser';
+export type { GroundedFormula, MLNFormula, MLNTheory, MLNWorld } from './types';
+export { allGroundAtoms, atomKey, evaluateGround, ground, groundFormula, renderGround, } from './grounding';
+export { exactMarginals, exactPartition, gibbsMarginals, gibbsSample, mapInference, probability, weight, } from './inference';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/markov-logic/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/markov-logic/index.ts"],"names":[],"mappings":"AA0BA,YAAY,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEnD,YAAY,EAAE,eAAe,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEhF,OAAO,EACL,cAAc,EACd,OAAO,EACP,cAAc,EACd,MAAM,EACN,aAAa,EACb,YAAY,GACb,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,cAAc,EACd,cAAc,EACd,cAAc,EACd,WAAW,EACX,YAAY,EACZ,WAAW,EACX,MAAM,GACP,MAAM,aAAa,CAAC"}

package/dist/runtime/markov-logic/index.js

@@ -0,0 +1,47 @@
+"use strict";
+// ============================================================
+// ST Markov Logic Networks — Barrel
+// ============================================================
+//
+// Una Markov Logic Network combina FOL con redes de Markov:
+// cada fórmula `F` lleva un peso `w` real; cada mundo `W` tiene
+// probabilidad
+//
+//   P(W) ∝ exp( Σ_i  w_i · n_i(W) )
+//
+// donde `n_i(W)` es el número de grounding instances de `F_i`
+// SATISFECHAS por `W`. Pesos +∞ representan hard constraints.
+//
+// API pública:
+//   - `ground(theory)`            → array de GroundedFormula
+//   - `weight(theory, world)`     → log-prob no normalizada
+//   - `probability(theory, world, Z)` → P(world) dada partición Z
+//   - `gibbsSample(theory, evidence, n)` → cadena de mundos
+//   - `gibbsMarginals(...)`       → P(atom=true) aproximada
+//   - `mapInference(theory, ev)`  → mundo más probable (MaxWalkSAT)
+//   - `exactPartition(theory)`    → Z exacta (sólo teorías chicas)
+//   - `exactMarginals(theory)`    → P(atom=true) exacta (chicas)
+//
+// Utilidades de grounding/parsing también expuestas para
+// herramientas (UI, debugging).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.weight = exports.probability = exports.mapInference = exports.gibbsSample = exports.gibbsMarginals = exports.exactPartition = exports.exactMarginals = exports.renderGround = exports.groundFormula = exports.ground = exports.evaluateGround = exports.atomKey = exports.allGroundAtoms = exports.parseFOL = exports.freeVariables = void 0;
+var parser_1 = require("./parser");
+Object.defineProperty(exports, "freeVariables", { enumerable: true, get: function () { return parser_1.freeVariables; } });
+Object.defineProperty(exports, "parseFOL", { enumerable: true, get: function () { return parser_1.parseFOL; } });
+var grounding_1 = require("./grounding");
+Object.defineProperty(exports, "allGroundAtoms", { enumerable: true, get: function () { return grounding_1.allGroundAtoms; } });
+Object.defineProperty(exports, "atomKey", { enumerable: true, get: function () { return grounding_1.atomKey; } });
+Object.defineProperty(exports, "evaluateGround", { enumerable: true, get: function () { return grounding_1.evaluateGround; } });
+Object.defineProperty(exports, "ground", { enumerable: true, get: function () { return grounding_1.ground; } });
+Object.defineProperty(exports, "groundFormula", { enumerable: true, get: function () { return grounding_1.groundFormula; } });
+Object.defineProperty(exports, "renderGround", { enumerable: true, get: function () { return grounding_1.renderGround; } });
+var inference_1 = require("./inference");
+Object.defineProperty(exports, "exactMarginals", { enumerable: true, get: function () { return inference_1.exactMarginals; } });
+Object.defineProperty(exports, "exactPartition", { enumerable: true, get: function () { return inference_1.exactPartition; } });
+Object.defineProperty(exports, "gibbsMarginals", { enumerable: true, get: function () { return inference_1.gibbsMarginals; } });
+Object.defineProperty(exports, "gibbsSample", { enumerable: true, get: function () { return inference_1.gibbsSample; } });
+Object.defineProperty(exports, "mapInference", { enumerable: true, get: function () { return inference_1.mapInference; } });
+Object.defineProperty(exports, "probability", { enumerable: true, get: function () { return inference_1.probability; } });
+Object.defineProperty(exports, "weight", { enumerable: true, get: function () { return inference_1.weight; } });
+//# sourceMappingURL=index.js.map

package/dist/runtime/markov-logic/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime/markov-logic/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,oCAAoC;AACpC,+DAA+D;AAC/D,EAAE;AACF,4DAA4D;AAC5D,gEAAgE;AAChE,eAAe;AACf,EAAE;AACF,oCAAoC;AACpC,EAAE;AACF,8DAA8D;AAC9D,8DAA8D;AAC9D,EAAE;AACF,eAAe;AACf,6DAA6D;AAC7D,4DAA4D;AAC5D,kEAAkE;AAClE,4DAA4D;AAC5D,4DAA4D;AAC5D,oEAAoE;AACpE,mEAAmE;AACnE,iEAAiE;AACjE,EAAE;AACF,yDAAyD;AACzD,gCAAgC;;;AAGhC,mCAAmD;AAA1C,uGAAA,aAAa,OAAA;AAAE,kGAAA,QAAQ,OAAA;AAIhC,yCAOqB;AANnB,2GAAA,cAAc,OAAA;AACd,oGAAA,OAAO,OAAA;AACP,2GAAA,cAAc,OAAA;AACd,mGAAA,MAAM,OAAA;AACN,0GAAA,aAAa,OAAA;AACb,yGAAA,YAAY,OAAA;AAGd,yCAQqB;AAPnB,2GAAA,cAAc,OAAA;AACd,2GAAA,cAAc,OAAA;AACd,2GAAA,cAAc,OAAA;AACd,wGAAA,WAAW,OAAA;AACX,yGAAA,YAAY,OAAA;AACZ,wGAAA,WAAW,OAAA;AACX,mGAAA,MAAM,OAAA"}

package/dist/runtime/markov-logic/inference.d.ts

@@ -0,0 +1,77 @@
+import type { MLNTheory, MLNWorld } from './types';
+/**
+ * Log-score (no normalizado) de un mundo:
+ *   logZW = Σ_i w_i · satisfied_i(world)
+ *
+ * Si la teoría tiene un hard constraint violado, devuelve
+ * `-Infinity` (lo cual hace P(world)=0).
+ */
+export declare function weight(theory: MLNTheory, world: MLNWorld): number;
+/**
+ * Probabilidad de un mundo dada una aproximación de la partición Z.
+ *
+ * P(world) = exp(weight(world)) / partitionApprox
+ *
+ * `partitionApprox` debe estar en el mismo "espacio" (no log).
+ * Si `weight(world) === -Infinity` devuelve 0.
+ */
+export declare function probability(theory: MLNTheory, world: MLNWorld, partitionApprox: number): number;
+/**
+ * Calcula la partición Z exactamente sumando sobre todos los mundos
+ * posibles. SOLO viable para teorías pequeñas (≤ ~20 ground atoms).
+ * Útil para tests.
+ */
+export declare function exactPartition(theory: MLNTheory): number;
+/**
+ * Marginales exactas P(atom = true) sobre todos los mundos.
+ * Mismo costo exponencial que `exactPartition`. Sólo para tests.
+ */
+export declare function exactMarginals(theory: MLNTheory): Record<string, number>;
+interface GibbsOptions {
+    /** RNG opcional para reproducibilidad. */
+    rng?: () => number;
+    /** Mundo inicial; si no se pasa, se randomiza respetando `evidence`. */
+    initial?: MLNWorld;
+    /** Cuántos warmup steps descartar antes de empezar a coleccionar (default 0). */
+    burnIn?: number;
+    /** Recolectar 1 cada `thin` pasos (default 1). */
+    thin?: number;
+}
+/**
+ * Gibbs sampling sobre los ground atoms NO evidenciados.
+ *
+ * En cada paso elige un atom no fijo y resamplea su valor según
+ * P(atom=true | resto). Para MLN, esa condicional es la sigmoide del
+ * "delta" de log-score al flippear:
+ *
+ *   P(atom=true | ·) = σ( logScore(true) − logScore(false) )
+ *
+ * Devuelve una secuencia de `iterations` mundos coleccionados tras
+ * `burnIn` pasos de calentamiento, con thinning opcional.
+ */
+export declare function gibbsSample(theory: MLNTheory, evidence: Partial<MLNWorld> | undefined, iterations: number, options?: GibbsOptions): MLNWorld[];
+/**
+ * Marginales aproximadas: corre Gibbs y promedia indicadores.
+ */
+export declare function gibbsMarginals(theory: MLNTheory, evidence: Partial<MLNWorld>, iterations: number, options?: GibbsOptions): Record<string, number>;
+interface MapOptions {
+    rng?: () => number;
+    /** Pasos máximos (default 5000). */
+    maxFlips?: number;
+    /** Reinicios independientes (default 5). */
+    restarts?: number;
+    /** Probabilidad de random walk en lugar de greedy (default 0.3). */
+    noise?: number;
+}
+/**
+ * MAP inference: encuentra el mundo de mayor `weight`. Aproximado
+ * mediante MaxWalkSAT con múltiples restarts: en cada paso, elige
+ * una ground formula INSATISFECHA y flippea uno de sus atoms; con
+ * probabilidad `noise` lo elige al azar (random walk), con `1-noise`
+ * elige el flip que más mejora el score (greedy).
+ *
+ * Respeta `evidence`: nunca flippea atoms fijos.
+ */
+export declare function mapInference(theory: MLNTheory, evidence?: Partial<MLNWorld>, options?: MapOptions): MLNWorld;
+export {};
+//# sourceMappingURL=inference.d.ts.map

package/dist/runtime/markov-logic/inference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inference.d.ts","sourceRoot":"","sources":["../../../src/runtime/markov-logic/inference.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAmB,SAAS,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEpE;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,GAAG,MAAM,CAGjE;AAkBD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM,CAO/F;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAkBxD;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAmCxE;AAID,UAAU,YAAY;IACpB,0CAA0C;IAC1C,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,wEAAwE;IACxE,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,iFAAiF;IACjF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kDAAkD;IAClD,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,SAAS,EACjB,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,YAAK,EAChC,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,YAAiB,GACzB,QAAQ,EAAE,CAiFZ;AA8BD;;GAEG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,SAAS,EACjB,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,EAC3B,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,YAAiB,GACzB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAcxB;AAID,UAAU,UAAU;IAClB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,oCAAoC;IACpC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,SAAS,EACjB,QAAQ,GAAE,OAAO,CAAC,QAAQ,CAAM,EAChC,OAAO,GAAE,UAAe,GACvB,QAAQ,CAkFV"}