@stevenvo780/st-lang 4.1.0 → 4.3.0

package/dist/runtime/mus/extract.d.ts

@@ -0,0 +1,34 @@
+import type { MUSOptions, MUSResult, SATOracle, AssumptionSolver } from './types';
+/**
+ * Extrae un MUS (Minimal Unsatisfiable Subset) del conjunto unsat
+ * `clauses` usando el oráculo SAT provisto.
+ *
+ * Convenciones:
+ *   - Las cláusulas son arrays de literales enteros estilo DIMACS
+ *     (positivo / negativo). El motor no inspecciona la semántica;
+ *     todo lo delega al `satOracle`.
+ *   - El conjunto retornado en `mus` son índices sobre `clauses`.
+ *   - Si `clauses` ES satisfacible, devolvemos `mus = []` (no hay
+ *     MUS posible).
+ *   - Determinismo: orden numérico ascendente en todos los recorridos.
+ */
+export declare function extractMUS(clauses: number[][], satOracle: SATOracle, opts?: MUSOptions): MUSResult;
+/**
+ * Variante para SAT solvers incrementales con assumptions.
+ *
+ * El patrón típico es:
+ *   - Por cada cláusula original `C_i`, añadir un selector literal
+ *     `s_i` y convertirla en `C_i ∨ ¬s_i` (la cláusula está "off"
+ *     cuando `s_i = false`).
+ *   - Para "activar" un subset, pasar las correspondientes `s_i` como
+ *     assumptions positivas.
+ *   - Cuando el problema es unsat, el solver devuelve
+ *     `failedAssumptions ⊆ assumptions` — el unsat core proyectado
+ *     sobre los selectors.
+ *
+ * Esta función toma el `failedAssumptions` como punto de partida y
+ * lo minimiza con un pase deletion-based usando el mismo solver para
+ * garantizar minimalidad por inclusión.
+ */
+export declare function extractMUSWithSelectors(clauses: number[][], selectors: number[], solver: AssumptionSolver, opts?: MUSOptions): MUSResult;
+//# sourceMappingURL=extract.d.ts.map

package/dist/runtime/mus/extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.d.ts","sourceRoot":"","sources":["../../../src/runtime/mus/extract.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAgB,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAuHhG;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CACxB,OAAO,EAAE,MAAM,EAAE,EAAE,EACnB,SAAS,EAAE,SAAS,EACpB,IAAI,GAAE,UAAe,GACpB,SAAS,CA8CX;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EAAE,EAAE,EACnB,SAAS,EAAE,MAAM,EAAE,EACnB,MAAM,EAAE,gBAAgB,EACxB,IAAI,GAAE,UAAe,GACpB,SAAS,CAsDX"}

package/dist/runtime/mus/extract.js

@@ -0,0 +1,243 @@
+"use strict";
+// ============================================================
+// ST MUS — Extracción de Minimal Unsatisfiable Subsets
+// ============================================================
+//
+// Algoritmos implementados:
+//   - deletion-based (O(n) llamadas SAT)
+//   - insertion-based (variante MARCO-like sencilla)
+//   - QuickXplain (delegado a `quickxplain.ts`)
+//
+// El oráculo SAT es una caja negra: cualquier función que dado un
+// array de cláusulas (literales enteros estilo DIMACS) devuelva
+// `true` si tiene modelo. Sound y completo según el oráculo provisto.
+//
+// También exponemos `extractMUSWithSelectors` para SAT solvers
+// incrementales que devuelven `failedAssumptions`: en ese caso
+// usamos la API del solver para conseguir un núcleo y luego lo
+// minimizamos.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractMUS = extractMUS;
+exports.extractMUSWithSelectors = extractMUSWithSelectors;
+const quickxplain_1 = require("./quickxplain");
+const DEFAULT_MAX_ITERATIONS = 100_000;
+function callOracle(state, ids) {
+    if (state.satCalls >= state.maxIterations)
+        return true; // forzar salida segura
+    const subset = [];
+    for (const id of ids) {
+        const c = state.byId.get(id);
+        if (c !== undefined)
+            subset.push(c);
+    }
+    state.satCalls++;
+    return state.oracle(subset);
+}
+// ── Deletion-based ─────────────────────────────────────────────
+/**
+ * Recorre cada cláusula del conjunto inicial; si removerla deja al
+ * resto unsat, la descarta. Garantiza minimalidad por inclusión al
+ * terminar el pase porque cada cláusula sobreviviente es "necesaria"
+ * en el contexto del conjunto sobreviviente.
+ *
+ * Detalle sutil: el orden de visita importa para *cuál* MUS se
+ * encuentra (puede haber varios). Usamos el orden numérico (id
+ * ascendente) para determinismo.
+ */
+function extractDeletion(state, allIds) {
+    let kept = allIds.slice().sort((a, b) => a - b);
+    for (const id of allIds.slice().sort((a, b) => a - b)) {
+        if (state.satCalls >= state.maxIterations)
+            break;
+        state.iterations++;
+        const candidate = kept.filter((x) => x !== id);
+        if (candidate.length === 0)
+            continue;
+        if (!callOracle(state, candidate)) {
+            // Sin esa cláusula sigue unsat → no es necesaria.
+            kept = candidate;
+        }
+    }
+    return kept;
+}
+// ── Insertion-based ────────────────────────────────────────────
+/**
+ * Variante "linear search" de MUS extraction (a veces llamada
+ * dichotomic / insertion). Itera:
+ *
+ *   1. Mantiene `mus = []` (núcleo crecido) y `pool = allIds`.
+ *   2. Va añadiendo cláusulas de `pool` a un `working` set hasta que
+ *      `mus ∪ working` se vuelve unsat. La última añadida es
+ *      "transition" — la promueve a `mus`.
+ *   3. Reset `working = []` y repite, recortando `pool` a las que
+ *      quedaron antes de la transition.
+ *   4. Termina cuando `mus` solo es unsat.
+ *
+ * Esto es esencialmente "augmenting MUS" / Junker's linear baseline.
+ * O(|MUS| · |C|) llamadas SAT en el peor caso, pero suele ser mucho
+ * más rápido en la práctica cuando |MUS| ≪ |C|.
+ */
+function extractInsertion(state, allIds) {
+    const mus = [];
+    let pool = allIds.slice().sort((a, b) => a - b);
+    // Caso base: si `[]` ya es unsat, el MUS es vacío.
+    state.iterations++;
+    if (!callOracle(state, []))
+        return [];
+    while (state.satCalls < state.maxIterations) {
+        state.iterations++;
+        // Si solo `mus` ya es unsat, terminamos.
+        if (!callOracle(state, mus))
+            break;
+        let working = [];
+        let transition = -1;
+        const consumed = [];
+        for (const id of pool) {
+            if (state.satCalls >= state.maxIterations)
+                break;
+            working = working.concat(id);
+            consumed.push(id);
+            if (!callOracle(state, mus.concat(working))) {
+                transition = id;
+                break;
+            }
+        }
+        if (transition === -1) {
+            // Defensa: si nunca se hizo unsat, el conjunto no era unsat para
+            // empezar (o se acabó el presupuesto). Salimos.
+            break;
+        }
+        mus.push(transition);
+        // Para el próximo loop solo nos quedamos con las cláusulas que se
+        // consumieron antes de la transition (excluyendo la transition).
+        // Esas son las "potencialmente irrelevantes" que aún hay que
+        // testear; las que estaban después en `pool` quedan ya cubiertas
+        // implícitamente por `mus`.
+        pool = consumed.filter((x) => x !== transition);
+    }
+    mus.sort((a, b) => a - b);
+    return mus;
+}
+// ── API pública ────────────────────────────────────────────────
+/**
+ * Extrae un MUS (Minimal Unsatisfiable Subset) del conjunto unsat
+ * `clauses` usando el oráculo SAT provisto.
+ *
+ * Convenciones:
+ *   - Las cláusulas son arrays de literales enteros estilo DIMACS
+ *     (positivo / negativo). El motor no inspecciona la semántica;
+ *     todo lo delega al `satOracle`.
+ *   - El conjunto retornado en `mus` son índices sobre `clauses`.
+ *   - Si `clauses` ES satisfacible, devolvemos `mus = []` (no hay
+ *     MUS posible).
+ *   - Determinismo: orden numérico ascendente en todos los recorridos.
+ */
+function extractMUS(clauses, satOracle, opts = {}) {
+    const algorithm = opts.algorithm ?? 'deletion';
+    const maxIterations = opts.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+    // Pre-check: el conjunto completo debe ser unsat. Si es sat, no hay
+    // MUS — devolvemos vacío.
+    if (satOracle(clauses)) {
+        return { mus: [], iterations: 1, satCalls: 1 };
+    }
+    if (clauses.length === 0) {
+        // `[]` es trivialmente sat, así que el pre-check ya habría
+        // devuelto. Defensa: nunca llegamos aquí porque sat([]) = true.
+        return { mus: [], iterations: 1, satCalls: 1 };
+    }
+    const byId = new Map();
+    clauses.forEach((c, i) => byId.set(i, c));
+    const allIds = clauses.map((_, i) => i);
+    if (algorithm === 'qx') {
+        const qx = (0, quickxplain_1.quickxplain)(clauses, satOracle, maxIterations);
+        // QuickXplain ya devuelve un MUS minimal por inclusión.
+        return { mus: qx.mus, iterations: 1, satCalls: qx.satCalls + 1 };
+    }
+    const state = {
+        oracle: satOracle,
+        byId,
+        satCalls: 1, // contamos el pre-check inicial
+        iterations: 0,
+        maxIterations,
+    };
+    let mus;
+    if (algorithm === 'insertion') {
+        mus = extractInsertion(state, allIds);
+    }
+    else {
+        mus = extractDeletion(state, allIds);
+    }
+    return {
+        mus: mus.slice().sort((a, b) => a - b),
+        iterations: state.iterations,
+        satCalls: state.satCalls,
+    };
+}
+// ── Variante con assumptions / selectors ───────────────────────
+/**
+ * Variante para SAT solvers incrementales con assumptions.
+ *
+ * El patrón típico es:
+ *   - Por cada cláusula original `C_i`, añadir un selector literal
+ *     `s_i` y convertirla en `C_i ∨ ¬s_i` (la cláusula está "off"
+ *     cuando `s_i = false`).
+ *   - Para "activar" un subset, pasar las correspondientes `s_i` como
+ *     assumptions positivas.
+ *   - Cuando el problema es unsat, el solver devuelve
+ *     `failedAssumptions ⊆ assumptions` — el unsat core proyectado
+ *     sobre los selectors.
+ *
+ * Esta función toma el `failedAssumptions` como punto de partida y
+ * lo minimiza con un pase deletion-based usando el mismo solver para
+ * garantizar minimalidad por inclusión.
+ */
+function extractMUSWithSelectors(clauses, selectors, solver, opts = {}) {
+    const maxIterations = opts.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+    if (clauses.length !== selectors.length) {
+        throw new Error(`extractMUSWithSelectors: clauses.length (${clauses.length}) !== selectors.length (${selectors.length})`);
+    }
+    let satCalls = 0;
+    let iterations = 0;
+    // Primera llamada con TODAS las assumptions activas.
+    satCalls++;
+    iterations++;
+    const initial = solver.solveWithAssumptions(selectors.slice());
+    if (initial.sat) {
+        return { mus: [], iterations, satCalls };
+    }
+    // Núcleo inicial: failedAssumptions si el solver lo da; sino, todos.
+    const selectorToIndex = new Map();
+    selectors.forEach((s, i) => selectorToIndex.set(s, i));
+    let core;
+    if (initial.failedAssumptions && initial.failedAssumptions.length > 0) {
+        core = initial.failedAssumptions
+            .map((s) => selectorToIndex.get(s))
+            .filter((idx) => idx !== undefined);
+    }
+    else {
+        core = clauses.map((_, i) => i);
+    }
+    core = Array.from(new Set(core)).sort((a, b) => a - b);
+    // Minimización deletion-based sobre el core con el mismo solver.
+    for (const idx of core.slice()) {
+        if (satCalls >= maxIterations)
+            break;
+        iterations++;
+        const candidate = core.filter((x) => x !== idx);
+        if (candidate.length === 0)
+            continue;
+        const assumptions = candidate.map((i) => selectors[i]);
+        satCalls++;
+        const res = solver.solveWithAssumptions(assumptions);
+        if (!res.sat) {
+            // Sin esa cláusula sigue unsat → no es necesaria.
+            core = candidate;
+        }
+    }
+    return {
+        mus: core.slice().sort((a, b) => a - b),
+        iterations,
+        satCalls,
+    };
+}
+//# sourceMappingURL=extract.js.map

package/dist/runtime/mus/extract.js.map

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

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

@@ -0,0 +1,4 @@
+export { extractMUS, extractMUSWithSelectors } from './extract';
+export { quickxplain } from './quickxplain';
+export type { MUSAlgorithm, MUSOptions, MUSResult, SATOracle, AssumptionSolver } from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/mus/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,UAAU,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC"}

package/dist/runtime/mus/index.js

@@ -0,0 +1,12 @@
+"use strict";
+// ============================================================
+// ST MUS — Barrel
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quickxplain = exports.extractMUSWithSelectors = exports.extractMUS = void 0;
+var extract_1 = require("./extract");
+Object.defineProperty(exports, "extractMUS", { enumerable: true, get: function () { return extract_1.extractMUS; } });
+Object.defineProperty(exports, "extractMUSWithSelectors", { enumerable: true, get: function () { return extract_1.extractMUSWithSelectors; } });
+var quickxplain_1 = require("./quickxplain");
+Object.defineProperty(exports, "quickxplain", { enumerable: true, get: function () { return quickxplain_1.quickxplain; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime/mus/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,kBAAkB;AAClB,+DAA+D;;;AAE/D,qCAAgE;AAAvD,qGAAA,UAAU,OAAA;AAAE,kHAAA,uBAAuB,OAAA;AAC5C,6CAA4C;AAAnC,0GAAA,WAAW,OAAA"}

package/dist/runtime/mus/quickxplain.d.ts

@@ -0,0 +1,10 @@
+import type { SATOracle } from './types';
+/**
+ * Ejecuta QuickXplain sobre el conjunto de cláusulas indexadas y
+ * devuelve los índices del MUS hallado más el conteo de llamadas SAT.
+ */
+export declare function quickxplain(clauses: number[][], oracle: SATOracle, maxIterations: number): {
+    mus: number[];
+    satCalls: number;
+};
+//# sourceMappingURL=quickxplain.d.ts.map

package/dist/runtime/mus/quickxplain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quickxplain.d.ts","sourceRoot":"","sources":["../../../src/runtime/mus/quickxplain.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAoEzC;;;GAGG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,EAAE,EAAE,EACnB,MAAM,EAAE,SAAS,EACjB,aAAa,EAAE,MAAM,GACpB;IAAE,GAAG,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAerC"}

package/dist/runtime/mus/quickxplain.js

@@ -0,0 +1,100 @@
+"use strict";
+// ============================================================
+// ST MUS — QuickXplain (Junker 2004)
+// ============================================================
+//
+// Divide-y-vencerás para encontrar un MUS dentro de un conjunto
+// `C = B ∪ U` donde `B` (background) ya se sabe consistente y
+// queremos hallar el subconjunto mínimo de `U` que es responsable
+// de la inconsistencia (junto con `B`).
+//
+// Pseudocódigo (versión simétrica clásica):
+//
+//   QX(B, ∆, C):
+//     if ∆ ≠ ∅ ∧ ¬sat(B):      return ∅              // ∆ no necesario
+//     if |C| = 1:               return C              // C es minimal
+//     C1, C2 = split(C)
+//     ∆1 = QX(B ∪ C1, C1, C2)
+//     ∆2 = QX(B ∪ ∆1, ∆1, C1)
+//     return ∆1 ∪ ∆2
+//
+// Cuidado: en la primera llamada `∆` debe ser ≠ ∅ para no caer en el
+// short-circuit. Convención típica: pasar `∆ = C` en el wrap externo.
+//
+// Complejidad: O(2k + 2k · log(n/k)) llamadas SAT, donde n = |C| y
+// k = |MUS|. Muy buena cuando k ≪ n.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quickxplain = quickxplain;
+/**
+ * Llama al oráculo con la unión de varios sets de ids. Si el contador
+ * de llamadas excede `maxIterations`, devuelve `true` (sat) para
+ * forzar la salida del algoritmo de forma segura.
+ */
+function check(state, ...sets) {
+    if (state.satCalls >= state.maxIterations)
+        return true;
+    const seen = new Set();
+    for (const s of sets)
+        for (const id of s)
+            seen.add(id);
+    const subset = [];
+    for (const id of seen) {
+        const clause = state.byId.get(id);
+        if (clause !== undefined)
+            subset.push(clause);
+    }
+    state.satCalls++;
+    return state.oracle(subset);
+}
+function qxRec(state, background, delta, candidates) {
+    // Si añadir delta hizo que el background sea unsat, delta no es necesario.
+    if (delta.length > 0 && !check(state, background)) {
+        return [];
+    }
+    if (candidates.length === 1) {
+        return candidates.slice();
+    }
+    if (state.satCalls >= state.maxIterations) {
+        return candidates.slice();
+    }
+    const mid = Math.floor(candidates.length / 2);
+    const left = candidates.slice(0, mid);
+    const right = candidates.slice(mid);
+    const delta1 = qxRec(state, mergeUnique(background, left), left, right);
+    const delta2 = qxRec(state, mergeUnique(background, delta1), delta1, left);
+    return mergeUnique(delta1, delta2);
+}
+function mergeUnique(a, b) {
+    if (a.length === 0)
+        return b.slice();
+    if (b.length === 0)
+        return a.slice();
+    const seen = new Set(a);
+    const out = a.slice();
+    for (const id of b) {
+        if (!seen.has(id)) {
+            seen.add(id);
+            out.push(id);
+        }
+    }
+    return out;
+}
+/**
+ * Ejecuta QuickXplain sobre el conjunto de cláusulas indexadas y
+ * devuelve los índices del MUS hallado más el conteo de llamadas SAT.
+ */
+function quickxplain(clauses, oracle, maxIterations) {
+    const byId = new Map();
+    clauses.forEach((c, i) => byId.set(i, c));
+    const ids = clauses.map((_, i) => i);
+    // Pre-check: si el conjunto completo ya es SAT, no hay MUS.
+    const state = { oracle, byId, satCalls: 0, maxIterations };
+    if (check(state, ids)) {
+        return { mus: [], satCalls: state.satCalls };
+    }
+    // En la primera llamada, ∆ = candidates para evitar short-circuit.
+    const mus = qxRec(state, [], ids, ids);
+    mus.sort((a, b) => a - b);
+    return { mus, satCalls: state.satCalls };
+}
+//# sourceMappingURL=quickxplain.js.map

package/dist/runtime/mus/quickxplain.js.map

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

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

@@ -0,0 +1,59 @@
+/**
+ * Algoritmos disponibles para extracción de MUS.
+ *
+ * - `deletion`: por cada cláusula c, prueba si C \ {c} sigue unsat;
+ *   si sí, descarta c definitivamente. O(n) llamadas al oráculo SAT.
+ *   Sencillo, robusto, fácil de auditar.
+ *
+ * - `insertion`: empieza con conjunto vacío W, agrega cláusulas una
+ *   por una. Cuando W se vuelve unsat, la última cláusula añadida es
+ *   "necesaria" (la fija en el MUS y vacía W). Repite hasta cubrir
+ *   todo. Útil cuando el MUS es pequeño respecto al total.
+ *
+ * - `qx`: QuickXplain (Junker 2004). Algoritmo divide-y-vencerás que
+ *   resuelve "minimum conflict explanation" con O(2k · log(n/k))
+ *   llamadas SAT, donde k es el tamaño del MUS. En la práctica mucho
+ *   más rápido que deletion para MUS grandes embebidos en problemas
+ *   inmensos.
+ */
+export type MUSAlgorithm = 'deletion' | 'insertion' | 'qx';
+export interface MUSOptions {
+    /** Algoritmo a usar. Default: `deletion`. */
+    algorithm?: MUSAlgorithm;
+    /** Tope superior de llamadas al oráculo SAT. Default: 100_000. */
+    maxIterations?: number;
+}
+export interface MUSResult {
+    /** Índices (sobre el array original `clauses`) que conforman el MUS. */
+    mus: number[];
+    /** Iteraciones de bucle externo (rondas del algoritmo). */
+    iterations: number;
+    /** Llamadas totales al oráculo SAT. */
+    satCalls: number;
+}
+/**
+ * Oráculo SAT: dado un conjunto de cláusulas (cada cláusula es una
+ * lista de literales enteros — convención DIMACS: positivo es literal
+ * positivo, negativo es negado), devuelve `true` sii el conjunto
+ * tiene un modelo, `false` si es unsat.
+ */
+export type SATOracle = (subset: number[][]) => boolean;
+/**
+ * Solver incremental con assumptions (estilo MiniSat / SAT4J):
+ * dadas N cláusulas hard y una lista de literales-asumidos, devuelve
+ * `{ sat: false, failedAssumptions: [...] }` cuando el problema es
+ * unsat — el array `failedAssumptions` contiene un subconjunto de las
+ * assumptions suficientes para que el problema sea unsat (el unsat
+ * core proyectado sobre assumptions).
+ *
+ * En la práctica `failedAssumptions` ya es un MUS (sobre la
+ * codificación por selectors) o un superset cercano; corremos un pase
+ * adicional de minimización para garantizar minimalidad.
+ */
+export interface AssumptionSolver {
+    solveWithAssumptions: (assumptions: number[]) => {
+        sat: boolean;
+        failedAssumptions?: number[];
+    };
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/runtime/mus/types.ts"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,WAAW,GAAG,IAAI,CAAC;AAE3D,MAAM,WAAW,UAAU;IACzB,6CAA6C;IAC7C,SAAS,CAAC,EAAE,YAAY,CAAC;IACzB,kEAAkE;IAClE,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,SAAS;IACxB,wEAAwE;IACxE,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,2DAA2D;IAC3D,UAAU,EAAE,MAAM,CAAC;IACnB,uCAAuC;IACvC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,KAAK,OAAO,CAAC;AAExD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,gBAAgB;IAC/B,oBAAoB,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK;QAC/C,GAAG,EAAE,OAAO,CAAC;QACb,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;KAC9B,CAAC;CACH"}

package/dist/runtime/mus/types.js

@@ -0,0 +1,20 @@
+"use strict";
+// ============================================================
+// ST MUS (Minimal Unsatisfiable Subset) — Tipos públicos
+// ============================================================
+//
+// Un MUS de un conjunto unsat C de cláusulas es un subconjunto
+// M ⊆ C tal que:
+//   1. M es insatisfacible (unsat).
+//   2. Para toda cláusula c ∈ M, M \ {c} es satisfacible (sat).
+//
+// Es decir: minimal por inclusión. NO necesariamente cardinality-
+// minimum — eso sería el smallest MUS y es Σ₂ᵖ-hard.
+//
+// Usos típicos en debugging de constraints / type errors:
+//   - Aislar el "núcleo" del conflicto cuando un sistema reporta
+//     unsat sobre cientos de cláusulas.
+//   - Explicar a un usuario por qué su conjunto de premisas es
+//     contradictorio.
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/runtime/mus/types.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,yDAAyD;AACzD,+DAA+D;AAC/D,EAAE;AACF,+DAA+D;AAC/D,iBAAiB;AACjB,oCAAoC;AACpC,gEAAgE;AAChE,EAAE;AACF,kEAAkE;AAClE,qDAAqD;AACrD,EAAE;AACF,0DAA0D;AAC1D,iEAAiE;AACjE,wCAAwC;AACxC,+DAA+D;AAC/D,sBAAsB"}

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

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

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

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

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

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

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

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

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

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

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

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