@stevenvo780/st-lang 4.1.0 → 4.3.0

package/dist/runtime/abduction/find.js

@@ -0,0 +1,202 @@
+"use strict";
+// ============================================================
+// ST Abduction — Núcleo: búsqueda de explicaciones
+// ============================================================
+//
+// Estrategia: enumeración por tamaño creciente (BFS sobre subsets).
+//
+//   for k in 0..maxSize:
+//     for cada subset H ⊆ abducibles con |H| = k:
+//       si KB ∪ H ⊨ O y KB ∪ H consistent:
+//         registrar H como explicación
+//         marcar todos sus supersets como redundantes (no parsimoniosos)
+//
+// Las explicaciones se reportan ordenadas por tamaño ascendente. La
+// minimalidad por inclusión se verifica al final con una pasada O(N²)
+// sobre las explicaciones encontradas (suficiente para |explicaciones|
+// ≲ algunos miles; en problemas grandes acotar `maxHypotheses`).
+//
+// Para `preferred = 'minimal'`, solo se reportan las parsimoniosas.
+// Para `minimum-cardinality`, se reportan únicamente las de tamaño
+// igual al mínimo encontrado. Para `minimum-cost`, las de costo
+// mínimo (requiere costFunction o se usa size).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findExplanations = findExplanations;
+exports.bestExplanation = bestExplanation;
+const entails_1 = require("./entails");
+function resolveOptions(abducibles, opts) {
+    const entails = opts?.entails ?? (0, entails_1.defaultEntails)();
+    const consistent = opts?.consistent ?? (0, entails_1.defaultConsistent)();
+    return {
+        entails,
+        consistent,
+        maxHypotheses: opts?.maxHypotheses ?? 1024,
+        maxSize: opts?.maxSize ?? abducibles.length,
+        costFunction: opts?.costFunction ?? (() => 1),
+        preferred: opts?.preferred ?? 'minimal',
+    };
+}
+/** Itera sobre todos los subsets de [0..n) de tamaño exactamente k (orden lex). */
+function* combinations(n, k) {
+    if (k < 0 || k > n)
+        return;
+    if (k === 0) {
+        yield [];
+        return;
+    }
+    const idx = new Array(k);
+    for (let i = 0; i < k; i++)
+        idx[i] = i;
+    while (true) {
+        yield idx.slice();
+        // Avanzar al siguiente combination en orden lex.
+        let i = k - 1;
+        while (i >= 0 && idx[i] === n - k + i)
+            i--;
+        if (i < 0)
+            return;
+        idx[i] = idx[i] + 1;
+        for (let j = i + 1; j < k; j++)
+            idx[j] = idx[j - 1] + 1;
+    }
+}
+function isSubsetOf(a, b) {
+    if (a.length > b.length)
+        return false;
+    let i = 0;
+    let j = 0;
+    while (i < a.length && j < b.length) {
+        const ai = a[i];
+        const bj = b[j];
+        if (ai === bj) {
+            i++;
+            j++;
+        }
+        else if (ai < bj) {
+            return false;
+        }
+        else {
+            j++;
+        }
+    }
+    return i === a.length;
+}
+/**
+ * Encuentra todas las explicaciones de un problema abductivo.
+ *
+ * - Enumera subsets de abducibles en orden creciente de tamaño.
+ * - Filtra los inconsistentes y los que no implican la observación.
+ * - Calcula minimalidad por inclusión (parsimony) post-hoc.
+ * - Aplica el filtro `preferred` para el output final.
+ */
+function findExplanations(problem, opts) {
+    const { kb, observation, abducibles } = problem;
+    const resolved = resolveOptions(abducibles, opts);
+    const n = abducibles.length;
+    const maxK = Math.min(resolved.maxSize, n);
+    // Pre-check: si KB ya implica O sin ninguna hipótesis, la explicación
+    // vacía es la única parsimoniosa.
+    // (Esto requiere consistencia de KB y derivación.)
+    const raw = [];
+    if (resolved.consistent(kb) && resolved.entails(kb, observation)) {
+        raw.push({ indices: [], hypotheses: [], costScore: 0 });
+    }
+    // Buscamos también H no vacíos. Si la vacía explica, según
+    // `preferred` puede ser todo lo que necesitamos (case-by-case).
+    outer: for (let k = 1; k <= maxK; k++) {
+        for (const idx of combinations(n, k)) {
+            const hypotheses = [];
+            let costScore = 0;
+            for (const i of idx) {
+                const f = abducibles[i];
+                if (f === undefined)
+                    continue;
+                hypotheses.push(f);
+                costScore += resolved.costFunction(f);
+            }
+            const combined = [...kb, ...hypotheses];
+            // Skip duplicate trivial: si algún subset menor ya está en raw y es
+            // subset de este, este NO va a ser parsimonious. Lo enumeramos
+            // igual porque `preferred=all` debe verlos, pero podemos saltarlo
+            // si `preferred` ∈ {minimal, minimum-cardinality, minimum-cost}.
+            if (resolved.preferred !== 'all' &&
+                raw.some((r) => r.indices.length < idx.length && isSubsetOf(r.indices, idx))) {
+                continue;
+            }
+            if (!resolved.consistent(combined))
+                continue;
+            if (!resolved.entails(combined, observation))
+                continue;
+            raw.push({ indices: idx, hypotheses, costScore });
+            if (raw.length >= resolved.maxHypotheses)
+                break outer;
+        }
+    }
+    // Determinar parsimony por inclusión: una H es parsimoniosa sii no
+    // existe H' ∈ raw con H' ⊂ H (subconjunto propio).
+    const parsimonyMap = new Map();
+    const keyFor = (r) => r.indices.join(',');
+    for (const r of raw) {
+        let parsim = true;
+        for (const other of raw) {
+            if (other === r)
+                continue;
+            if (other.indices.length >= r.indices.length)
+                continue;
+            if (isSubsetOf(other.indices, r.indices)) {
+                parsim = false;
+                break;
+            }
+        }
+        parsimonyMap.set(keyFor(r), parsim);
+    }
+    // Convertir a Explanation[].
+    const explanations = raw.map((r) => ({
+        hypotheses: r.hypotheses,
+        size: r.hypotheses.length,
+        parsimonious: parsimonyMap.get(keyFor(r)) ?? false,
+        costScore: r.costScore,
+    }));
+    return applyPreference(explanations, resolved);
+}
+function applyPreference(expls, resolved) {
+    if (expls.length === 0)
+        return [];
+    switch (resolved.preferred) {
+        case 'all':
+            return expls.slice();
+        case 'minimal':
+            return expls.filter((e) => e.parsimonious);
+        case 'minimum-cardinality': {
+            const minimal = expls.filter((e) => e.parsimonious);
+            if (minimal.length === 0)
+                return [];
+            const minSize = minimal.reduce((m, e) => Math.min(m, e.size), Infinity);
+            return minimal.filter((e) => e.size === minSize);
+        }
+        case 'minimum-cost': {
+            const minimal = expls.filter((e) => e.parsimonious);
+            if (minimal.length === 0)
+                return [];
+            const minCost = minimal.reduce((m, e) => Math.min(m, e.costScore ?? Infinity), Infinity);
+            return minimal.filter((e) => (e.costScore ?? Infinity) === minCost);
+        }
+        default:
+            return expls.slice();
+    }
+}
+/**
+ * Devuelve UNA explicación: la "mejor" según `preferred`. Si hay
+ * empate, la primera en orden lex (consistente y reproducible).
+ *
+ * Devuelve `null` si no hay explicación posible.
+ */
+function bestExplanation(problem, opts) {
+    // Para best-explanation, forzamos minimum-cost si hay costFunction;
+    // si no, minimum-cardinality. El cliente puede overridear con
+    // opts.preferred.
+    const preferred = opts?.preferred ?? (opts?.costFunction ? 'minimum-cost' : 'minimum-cardinality');
+    const all = findExplanations(problem, { ...opts, preferred });
+    return all.length > 0 ? all[0] : null;
+}
+//# sourceMappingURL=find.js.map

package/dist/runtime/abduction/find.js.map

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

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

@@ -0,0 +1,4 @@
+export { findExplanations, bestExplanation } from './find';
+export { defaultEntails, defaultConsistent } from './entails';
+export type { AbductionOptions, AbductionProblem, ConsistencyOracle, EntailmentOracle, Explanation, Formula, Preference, } from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/abduction/index.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC9D,YAAY,EACV,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,WAAW,EACX,OAAO,EACP,UAAU,GACX,MAAM,SAAS,CAAC"}

package/dist/runtime/abduction/index.js

@@ -0,0 +1,26 @@
+"use strict";
+// ============================================================
+// ST Abduction — Barrel
+// ============================================================
+//
+// Razonamiento abductivo: dado un knowledge base KB y una observación
+// O, encontrar la hipótesis mínima H ⊆ Abducibles tal que
+// KB ∪ H ⊨ O y KB ∪ H es consistente.
+//
+// API pública:
+//   - `findExplanations(problem, opts?)`  → todas las explicaciones
+//   - `bestExplanation(problem, opts?)`   → la mejor según preferencia
+//   - `defaultEntails(opts?)`             → oráculo entailment Horn-like
+//   - `defaultConsistent(opts?)`          → oráculo consistencia derivado
+//
+// Tipos: `AbductionProblem`, `Explanation`, `AbductionOptions`,
+// `EntailmentOracle`, `ConsistencyOracle`, `Preference`, `Formula`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultConsistent = exports.defaultEntails = exports.bestExplanation = exports.findExplanations = void 0;
+var find_1 = require("./find");
+Object.defineProperty(exports, "findExplanations", { enumerable: true, get: function () { return find_1.findExplanations; } });
+Object.defineProperty(exports, "bestExplanation", { enumerable: true, get: function () { return find_1.bestExplanation; } });
+var entails_1 = require("./entails");
+Object.defineProperty(exports, "defaultEntails", { enumerable: true, get: function () { return entails_1.defaultEntails; } });
+Object.defineProperty(exports, "defaultConsistent", { enumerable: true, get: function () { return entails_1.defaultConsistent; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime/abduction/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,wBAAwB;AACxB,+DAA+D;AAC/D,EAAE;AACF,sEAAsE;AACtE,0DAA0D;AAC1D,sCAAsC;AACtC,EAAE;AACF,eAAe;AACf,oEAAoE;AACpE,uEAAuE;AACvE,yEAAyE;AACzE,0EAA0E;AAC1E,EAAE;AACF,gEAAgE;AAChE,oEAAoE;;;AAEpE,+BAA2D;AAAlD,wGAAA,gBAAgB,OAAA;AAAE,uGAAA,eAAe,OAAA;AAC1C,qCAA8D;AAArD,yGAAA,cAAc,OAAA;AAAE,4GAAA,iBAAiB,OAAA"}

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

@@ -0,0 +1,78 @@
+/** Una fórmula (formato libre — strings, opaque al motor). */
+export type Formula = string;
+/**
+ * Oráculo de consecuencia lógica: dado un conjunto de premisas P y
+ * una fórmula objetivo q, devuelve `true` sii P ⊨ q.
+ *
+ * El motor abductivo es agnóstico al sistema lógico. Quien usa la
+ * librería provee este oráculo (puede ser propositional, FOL,
+ * description logic, etc).
+ */
+export type EntailmentOracle = (premises: ReadonlyArray<Formula>, target: Formula) => boolean;
+/**
+ * Oráculo de consistencia: dado un conjunto de fórmulas, devuelve
+ * `true` sii admite al menos un modelo. Default razonable: si no
+ * lo dan, decimos consistente sii NO P ⊨ ⊥. Como no tenemos ⊥
+ * estándar en strings, en la práctica conviene pasar este oráculo.
+ */
+export type ConsistencyOracle = (premises: ReadonlyArray<Formula>) => boolean;
+/**
+ * Problema abductivo.
+ *
+ * - `kb`: background knowledge (axiomas del dominio).
+ * - `observation`: fórmula que queremos explicar.
+ * - `abducibles`: el conjunto de fórmulas elegibles como hipótesis.
+ *   El razonador buscará H ⊆ abducibles.
+ */
+export interface AbductionProblem {
+    kb: ReadonlyArray<Formula>;
+    observation: Formula;
+    abducibles: ReadonlyArray<Formula>;
+}
+/**
+ * Una explicación candidata.
+ *
+ * - `hypotheses`: subconjunto de abducibles.
+ * - `size`: cardinalidad (= hypotheses.length).
+ * - `parsimonious`: true sii no existe subconjunto propio que
+ *   también explique la observación de forma consistente.
+ *   (Equivale a "minimal por inclusión".)
+ * - `costScore`: suma de costos si se proveyó costFunction.
+ */
+export interface Explanation {
+    hypotheses: ReadonlyArray<Formula>;
+    size: number;
+    parsimonious: boolean;
+    costScore?: number;
+}
+/**
+ * Criterio de preferencia sobre el conjunto de explicaciones.
+ *
+ * - `all`: todas las explicaciones encontradas (no filtra).
+ * - `minimal`: solo las minimal-por-inclusión (parsimonious).
+ * - `minimum-cardinality`: las de menor |H| entre las minimales.
+ * - `minimum-cost`: las de menor costo total (requiere costFunction).
+ */
+export type Preference = 'all' | 'minimal' | 'minimum-cardinality' | 'minimum-cost';
+export interface AbductionOptions {
+    /** Oráculo de entailment. Default: `defaultEntails` (propositional, ver entails.ts). */
+    entails?: EntailmentOracle;
+    /** Oráculo de consistencia. Default: derivado de `entails` (no entails ⊥-equiv). */
+    consistent?: ConsistencyOracle;
+    /**
+     * Tope de explicaciones a retornar. Útil cuando hay explosión
+     * combinatoria. Default: 1024.
+     */
+    maxHypotheses?: number;
+    /**
+     * Tope para |H|. Acota el espacio de búsqueda. Default: igual a
+     * |abducibles| (sin tope efectivo). Bajarlo es una buena idea
+     * para |abducibles| > 12.
+     */
+    maxSize?: number;
+    /** Función de costo por hipótesis. Default: 1 por hipótesis. */
+    costFunction?: (h: Formula) => number;
+    /** Cómo filtrar/ordenar el output. Default: `minimal`. */
+    preferred?: Preference;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/runtime/abduction/types.ts"],"names":[],"mappings":"AAqBA,8DAA8D;AAC9D,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC;AAE7B;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC;AAE9F;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC;AAE9E;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAC3B,WAAW,EAAE,OAAO,CAAC;IACrB,UAAU,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;CACpC;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,SAAS,GAAG,qBAAqB,GAAG,cAAc,CAAC;AAEpF,MAAM,WAAW,gBAAgB;IAC/B,wFAAwF;IACxF,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,oFAAoF;IACpF,UAAU,CAAC,EAAE,iBAAiB,CAAC;IAC/B;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gEAAgE;IAChE,YAAY,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,MAAM,CAAC;IACtC,0DAA0D;IAC1D,SAAS,CAAC,EAAE,UAAU,CAAC;CACxB"}

package/dist/runtime/abduction/types.js

@@ -0,0 +1,23 @@
+"use strict";
+// ============================================================
+// ST Abduction — Tipos públicos
+// ============================================================
+//
+// Razonamiento abductivo (Peirce 1903; Reiter 1987): dado un
+// background knowledge KB y una observación O, encontrar
+// hipótesis H ⊆ Abducibles tal que:
+//
+//   1. KB ∪ H ⊨ O       (la hipótesis explica la observación)
+//   2. KB ∪ H consistent (la hipótesis es compatible con KB)
+//   3. H es minimal (no hay H' ⊂ H que cumpla 1 y 2)
+//
+// Usos típicos:
+//   - Diagnóstico (¿qué fallas explican estos síntomas?)
+//   - Inferencia best-fit (la hipótesis más simple/barata gana)
+//   - Generación de explicaciones (debugging de cadenas causales)
+//
+// El espacio de hipótesis se enumera sobre 2^|abducibles|. Para
+// |abducibles| ≲ 16 la enumeración exhaustiva es viable. Para más
+// grande, conviene un oráculo SAT incremental.
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/runtime/abduction/types.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,gCAAgC;AAChC,+DAA+D;AAC/D,EAAE;AACF,6DAA6D;AAC7D,yDAAyD;AACzD,oCAAoC;AACpC,EAAE;AACF,8DAA8D;AAC9D,6DAA6D;AAC7D,qDAAqD;AACrD,EAAE;AACF,gBAAgB;AAChB,yDAAyD;AACzD,gEAAgE;AAChE,kEAAkE;AAClE,EAAE;AACF,gEAAgE;AAChE,kEAAkE;AAClE,+CAA+C"}

package/dist/runtime/bayesian/factor.d.ts

@@ -0,0 +1,22 @@
+import type { BayesianNetwork, CPT, Evidence } from './types';
+export interface Factor {
+    variables: string[];
+    domains: Record<string, string[]>;
+    values: Map<string, number>;
+}
+export declare function assignmentKey(variables: string[], assignment: Record<string, string>): string;
+export declare function parseParentKey(parents: string[], key: string): Record<string, string>;
+export declare function buildParentKey(parents: string[], assignment: Record<string, string>): string;
+export declare function iterateAssignments(variables: string[], domains: Record<string, string[]>): Generator<Record<string, string>>;
+export declare function factorFromCPT(cpt: CPT, variableDomains: Record<string, string[]>): Factor;
+export declare function restrictFactor(factor: Factor, evidence: Evidence): Factor;
+export declare function parseAssignmentKey(key: string): Record<string, string>;
+export declare function multiplyFactors(a: Factor, b: Factor): Factor;
+export declare function sumOut(factor: Factor, variable: string): Factor;
+export declare function maxOut(factor: Factor, variable: string): {
+    factor: Factor;
+    backpointer: Map<string, string>;
+};
+export declare function normalizeFactor(factor: Factor): Factor;
+export declare function variableDomainsOf(net: BayesianNetwork): Record<string, string[]>;
+//# sourceMappingURL=factor.d.ts.map

package/dist/runtime/bayesian/factor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factor.d.ts","sourceRoot":"","sources":["../../../src/runtime/bayesian/factor.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,eAAe,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE9D,MAAM,WAAW,MAAM;IACrB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAGlC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC7B;AAID,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAO7F;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAYrF;AAGD,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAO5F;AAID,wBAAiB,kBAAkB,CACjC,SAAS,EAAE,MAAM,EAAE,EACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAChC,SAAS,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CA0BnC;AAID,wBAAgB,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,MAAM,CAqBzF;AAID,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAsBzE;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAStE;AAID,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAgB5D;AAUD,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAc/D;AAQD,wBAAgB,MAAM,CACpB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAwBtD;AAID,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAUtD;AAID,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAIhF"}

package/dist/runtime/bayesian/factor.js

@@ -0,0 +1,249 @@
+"use strict";
+// ============================================================
+// Bayesian Inference — Factor representation
+// ============================================================
+//
+// Un Factor representa una función φ(X₁,…,Xₙ) → ℝ⁺ sobre un
+// conjunto de variables discretas. Las CPTs se convierten a
+// factores; los algoritmos de variable elimination producen
+// y consumen factores con tres operaciones: restricción por
+// evidencia, producto, y suma-marginalización.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignmentKey = assignmentKey;
+exports.parseParentKey = parseParentKey;
+exports.buildParentKey = buildParentKey;
+exports.iterateAssignments = iterateAssignments;
+exports.factorFromCPT = factorFromCPT;
+exports.restrictFactor = restrictFactor;
+exports.parseAssignmentKey = parseAssignmentKey;
+exports.multiplyFactors = multiplyFactors;
+exports.sumOut = sumOut;
+exports.maxOut = maxOut;
+exports.normalizeFactor = normalizeFactor;
+exports.variableDomainsOf = variableDomainsOf;
+// ── Helpers de claves ─────────────────────────────────────────
+function assignmentKey(variables, assignment) {
+    // Asume `variables` ya está ordenado consistentemente.
+    const parts = [];
+    for (const v of variables) {
+        parts.push(`${v}=${assignment[v]}`);
+    }
+    return parts.join('|');
+}
+function parseParentKey(parents, key) {
+    const out = {};
+    if (parents.length === 0)
+        return out;
+    const parts = key.split('|');
+    for (const part of parts) {
+        const eq = part.indexOf('=');
+        if (eq < 0)
+            continue;
+        const k = part.slice(0, eq);
+        const v = part.slice(eq + 1);
+        out[k] = v;
+    }
+    return out;
+}
+// Construye la clave canónica de padres en el orden declarado por el CPT.
+function buildParentKey(parents, assignment) {
+    if (parents.length === 0)
+        return '';
+    const parts = [];
+    for (const p of parents) {
+        parts.push(`${p}=${assignment[p]}`);
+    }
+    return parts.join('|');
+}
+// ── Iteración cartesiana sobre dominios ──────────────────────
+function* iterateAssignments(variables, domains) {
+    if (variables.length === 0) {
+        yield {};
+        return;
+    }
+    const sizes = variables.map((v) => domains[v]?.length ?? 0);
+    if (sizes.some((s) => s === 0))
+        return;
+    const idx = variables.map(() => 0);
+    while (true) {
+        const a = {};
+        for (let i = 0; i < variables.length; i++) {
+            const v = variables[i];
+            const dom = domains[v];
+            a[v] = dom[idx[i]];
+        }
+        yield a;
+        // incrementar como contador
+        let k = variables.length - 1;
+        while (k >= 0) {
+            idx[k] = (idx[k] ?? 0) + 1;
+            if (idx[k] < sizes[k])
+                break;
+            idx[k] = 0;
+            k--;
+        }
+        if (k < 0)
+            break;
+    }
+}
+// ── Construcción de factor desde CPT ─────────────────────────
+function factorFromCPT(cpt, variableDomains) {
+    const factorVars = [cpt.variable, ...cpt.parents].slice().sort();
+    const domains = {};
+    for (const v of factorVars) {
+        const dom = variableDomains[v];
+        if (!dom)
+            throw new Error(`Variable "${v}" sin dominio definido`);
+        domains[v] = dom;
+    }
+    const values = new Map();
+    for (const assign of iterateAssignments(factorVars, domains)) {
+        const parentKey = buildParentKey(cpt.parents, assign);
+        const row = cpt.entries[parentKey];
+        if (!row) {
+            // Fila ausente: probabilidad 0 (red mal definida — pero no fallamos aquí).
+            values.set(assignmentKey(factorVars, assign), 0);
+            continue;
+        }
+        const p = row[assign[cpt.variable]];
+        values.set(assignmentKey(factorVars, assign), p ?? 0);
+    }
+    return { variables: factorVars, domains, values };
+}
+// ── Restricción por evidencia ────────────────────────────────
+function restrictFactor(factor, evidence) {
+    const evVars = factor.variables.filter((v) => v in evidence);
+    if (evVars.length === 0)
+        return factor;
+    const newVars = factor.variables.filter((v) => !(v in evidence));
+    const newDomains = {};
+    for (const v of newVars)
+        newDomains[v] = factor.domains[v];
+    const values = new Map();
+    for (const [key, val] of factor.values) {
+        const assign = parseAssignmentKey(key);
+        let consistent = true;
+        for (const ev of evVars) {
+            if (assign[ev] !== evidence[ev]) {
+                consistent = false;
+                break;
+            }
+        }
+        if (!consistent)
+            continue;
+        const projected = {};
+        for (const v of newVars)
+            projected[v] = assign[v];
+        values.set(assignmentKey(newVars, projected), val);
+    }
+    return { variables: newVars, domains: newDomains, values };
+}
+function parseAssignmentKey(key) {
+    if (key === '')
+        return {};
+    const out = {};
+    for (const part of key.split('|')) {
+        const eq = part.indexOf('=');
+        if (eq < 0)
+            continue;
+        out[part.slice(0, eq)] = part.slice(eq + 1);
+    }
+    return out;
+}
+// ── Producto de factores ─────────────────────────────────────
+function multiplyFactors(a, b) {
+    const varSet = new Set([...a.variables, ...b.variables]);
+    const newVars = Array.from(varSet).sort();
+    const domains = {};
+    for (const v of newVars) {
+        domains[v] = a.domains[v] ?? b.domains[v];
+    }
+    const values = new Map();
+    for (const assign of iterateAssignments(newVars, domains)) {
+        const aKey = assignmentKey(a.variables, projectAssignment(assign, a.variables));
+        const bKey = assignmentKey(b.variables, projectAssignment(assign, b.variables));
+        const va = a.values.get(aKey) ?? 0;
+        const vb = b.values.get(bKey) ?? 0;
+        values.set(assignmentKey(newVars, assign), va * vb);
+    }
+    return { variables: newVars, domains, values };
+}
+function projectAssignment(assign, vars) {
+    const out = {};
+    for (const v of vars)
+        out[v] = assign[v];
+    return out;
+}
+// ── Suma-marginalización ─────────────────────────────────────
+function sumOut(factor, variable) {
+    if (!factor.variables.includes(variable))
+        return factor;
+    const newVars = factor.variables.filter((v) => v !== variable);
+    const newDomains = {};
+    for (const v of newVars)
+        newDomains[v] = factor.domains[v];
+    const values = new Map();
+    for (const [key, val] of factor.values) {
+        const assign = parseAssignmentKey(key);
+        const projected = {};
+        for (const v of newVars)
+            projected[v] = assign[v];
+        const pKey = assignmentKey(newVars, projected);
+        values.set(pKey, (values.get(pKey) ?? 0) + val);
+    }
+    return { variables: newVars, domains: newDomains, values };
+}
+// ── Max-marginalización (para MPE) ───────────────────────────
+//
+// Devuelve dos factores: el factor max-marginalizado y un mapa
+// backpointer key→valor(varEliminada) usado para reconstruir el
+// argmax.
+function maxOut(factor, variable) {
+    if (!factor.variables.includes(variable)) {
+        return { factor, backpointer: new Map() };
+    }
+    const newVars = factor.variables.filter((v) => v !== variable);
+    const newDomains = {};
+    for (const v of newVars)
+        newDomains[v] = factor.domains[v];
+    const values = new Map();
+    const backpointer = new Map();
+    for (const [key, val] of factor.values) {
+        const assign = parseAssignmentKey(key);
+        const projected = {};
+        for (const v of newVars)
+            projected[v] = assign[v];
+        const pKey = assignmentKey(newVars, projected);
+        const prev = values.get(pKey);
+        if (prev === undefined || val > prev) {
+            values.set(pKey, val);
+            backpointer.set(`${pKey}::${variable}`, assign[variable]);
+        }
+    }
+    return {
+        factor: { variables: newVars, domains: newDomains, values },
+        backpointer,
+    };
+}
+// ── Normalización ────────────────────────────────────────────
+function normalizeFactor(factor) {
+    let total = 0;
+    for (const v of factor.values.values())
+        total += v;
+    if (total === 0) {
+        // Evidencia inconsistente: devolver factor uniforme nulo.
+        return factor;
+    }
+    const values = new Map();
+    for (const [k, v] of factor.values)
+        values.set(k, v / total);
+    return { variables: factor.variables, domains: factor.domains, values };
+}
+// ── Utilidades de red ────────────────────────────────────────
+function variableDomainsOf(net) {
+    const out = {};
+    for (const v of net.variables)
+        out[v.name] = v.values;
+    return out;
+}
+//# sourceMappingURL=factor.js.map