@stevenvo780/st-lang 4.3.0 → 4.5.0

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

@@ -0,0 +1,54 @@
+/**
+ * Restricción n-aria de un CSP.
+ *
+ *  - `vars`      variables sobre las que aplica el predicado, en orden.
+ *  - `predicate` función que recibe los valores alineados a `vars` y
+ *                devuelve `true` si la tupla es admisible.
+ *
+ * Para AC-3 estricto sólo usamos restricciones binarias; para
+ * restricciones n-arias el algoritmo cae a forward-checking equivalente:
+ * cada restricción se evalúa cuando todas sus variables están asignadas.
+ */
+export interface Constraint<V, D> {
+    vars: V[];
+    predicate: (vals: D[]) => boolean;
+}
+/**
+ * CSP genérico. `variables` define el orden canónico; `domains` mapea
+ * cada variable a sus posibles valores. Las restricciones pueden ser
+ * binarias (sweet spot de AC-3) o n-arias.
+ */
+export interface CSP<V, D> {
+    variables: V[];
+    domains: Map<V, D[]>;
+    constraints: Constraint<V, D>[];
+}
+/**
+ * Resultado de una corrida de backtracking.
+ *  - `solution`   asignación completa o `null` si UNSAT.
+ *  - `iterations` nodos del árbol de búsqueda visitados.
+ *  - `failures`   asignaciones que dispararon backtrack.
+ */
+export interface CSPResult<V, D> {
+    solution: Map<V, D> | null;
+    iterations: number;
+    failures: number;
+}
+/**
+ * Opciones de configuración para el solver.
+ *  - `useAC3` aplica AC-3 antes de empezar (y opcionalmente tras cada
+ *             asignación si `maintainAC3` está activo).
+ *  - `mrv`    heurística "Minimum Remaining Values" para elegir la
+ *             próxima variable: la de dominio reducido más pequeño.
+ *  - `lcv`    heurística "Least Constraining Value" para ordenar
+ *             valores: probar primero el que menos restringe a vecinos.
+ *  - `maxIterations` corta la búsqueda tras N nodos (defensa contra
+ *                    explosión combinatoria).
+ */
+export interface BacktrackOptions {
+    useAC3?: boolean;
+    mrv?: boolean;
+    lcv?: boolean;
+    maxIterations?: number;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/runtime/csp/types.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;GAUG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC,EAAE,CAAC;IAC9B,IAAI,EAAE,CAAC,EAAE,CAAC;IACV,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC;CACnC;AAED;;;;GAIG;AACH,MAAM,WAAW,GAAG,CAAC,CAAC,EAAE,CAAC;IACvB,SAAS,EAAE,CAAC,EAAE,CAAC;IACf,OAAO,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IACrB,WAAW,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;CACjC;AAED;;;;;GAKG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,EAAE,CAAC;IAC7B,QAAQ,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB"}

package/dist/runtime/csp/types.js

@@ -0,0 +1,14 @@
+"use strict";
+// ============================================================
+// CSP — Constraint Satisfaction Problem, tipos públicos.
+// ============================================================
+// Un CSP es una tripla (X, D, C) donde:
+//   X = variables
+//   D = dominios finitos por variable (D: X → 2^Vals)
+//   C = restricciones sobre subconjuntos de variables
+//
+// Cada restricción es un predicado n-ario que decide si una tupla de
+// valores (alineada al orden de `vars`) es admisible.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/runtime/csp/types.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,yDAAyD;AACzD,+DAA+D;AAC/D,wCAAwC;AACxC,kBAAkB;AAClB,sDAAsD;AACtD,sDAAsD;AACtD,EAAE;AACF,qEAAqE;AACrE,sDAAsD;AACtD,+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"}