@stevenvo780/st-lang 4.5.1 → 4.6.0

package/dist/bdd/index.d.ts

@@ -0,0 +1,4 @@
+export { BDDManager } from './manager';
+export type { BDDNode, BDDStats } from './types';
+export { isTerminal, nodeId } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/bdd/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bdd/index.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC"}

package/dist/bdd/index.js

@@ -0,0 +1,29 @@
+"use strict";
+// ============================================================
+// ST BDD — Punto de entrada público
+// ============================================================
+//
+// Reduced Ordered Binary Decision Diagrams (ROBDDs) de Bryant (1986).
+//
+// API principal:
+//   - `BDDManager(numVars)` crea un manager con orden por defecto 0..n-1.
+//   - `variable(i)`, `not_`, `and_`, `or_`, `xor`, `implies`, `iff`, `ite`
+//     construyen y combinan BDDs canónicos.
+//   - `exists(v, b)`, `forall(v, b)` cuantifican.
+//   - `satCount`, `isSatisfiable`, `isValid`, `equivalent`, `evaluate`
+//     consultan.
+//   - `fromCNF(clauses)` ingiere SAT en formato DIMACS.
+//   - `fromFormula(ast)` ingiere árboles simbólicos.
+//
+// Garantías:
+//   - Canonicidad estructural: dos BDDs equivalentes son la misma
+//     referencia (apt para `equivalent` en O(1)).
+//   - Apply algorithm con memoización: AND/OR/XOR en O(|G1|·|G2|).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeId = exports.isTerminal = exports.BDDManager = void 0;
+var manager_1 = require("./manager");
+Object.defineProperty(exports, "BDDManager", { enumerable: true, get: function () { return manager_1.BDDManager; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "isTerminal", { enumerable: true, get: function () { return types_1.isTerminal; } });
+Object.defineProperty(exports, "nodeId", { enumerable: true, get: function () { return types_1.nodeId; } });
+//# sourceMappingURL=index.js.map

package/dist/bdd/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/bdd/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,oCAAoC;AACpC,+DAA+D;AAC/D,EAAE;AACF,sEAAsE;AACtE,EAAE;AACF,iBAAiB;AACjB,0EAA0E;AAC1E,2EAA2E;AAC3E,4CAA4C;AAC5C,kDAAkD;AAClD,uEAAuE;AACvE,iBAAiB;AACjB,wDAAwD;AACxD,qDAAqD;AACrD,EAAE;AACF,aAAa;AACb,kEAAkE;AAClE,kDAAkD;AAClD,mEAAmE;;;AAEnE,qCAAuC;AAA9B,qGAAA,UAAU,OAAA;AAEnB,iCAA6C;AAApC,mGAAA,UAAU,OAAA;AAAE,+FAAA,MAAM,OAAA"}

package/dist/bdd/manager.d.ts

@@ -0,0 +1,122 @@
+import type { BDDNode, BDDStats } from './types';
+export declare class BDDManager {
+    numVars: number;
+    private readonly TRUE;
+    private readonly FALSE;
+    private uniqueTable;
+    private nextId;
+    private reductions;
+    private memoAnd;
+    private memoOr;
+    private memoXor;
+    private memoIte;
+    private memoNot;
+    varOrder: number[];
+    constructor(numVars: number);
+    /**
+     * Cambia el orden global de variables. Invalida memo caches porque
+     * el orden afecta la estructura de los nodos. NO reordena nodos ya
+     * construidos — si los reutilizas tras setVarOrder pueden quedar
+     * inconsistentes; recomendado para sesiones nuevas.
+     */
+    setVarOrder(order: number[]): void;
+    /** Posición de la variable v dentro del orden actual (0 = top). */
+    private orderPos;
+    /** Devuelve la variable "top" de un nodo o +∞ si es terminal. */
+    private topVarPos;
+    true_(): BDDNode;
+    false_(): BDDNode;
+    /**
+     * Crea/recupera un nodo interno con reducción (R1) + (R2).
+     */
+    private makeNode;
+    /** BDD de la variable i: nodo (i, FALSE, TRUE). */
+    variable(i: number): BDDNode;
+    /**
+     * Negación: implementada como ITE(b, FALSE, TRUE).
+     * Con memo dedicado para evitar recomputación.
+     */
+    not_(b: BDDNode): BDDNode;
+    and_(a: BDDNode, b: BDDNode): BDDNode;
+    or_(a: BDDNode, b: BDDNode): BDDNode;
+    xor(a: BDDNode, b: BDDNode): BDDNode;
+    /** A → B ≡ ¬A ∨ B */
+    implies(a: BDDNode, b: BDDNode): BDDNode;
+    /** A ↔ B ≡ ¬(A ⊕ B) */
+    iff(a: BDDNode, b: BDDNode): BDDNode;
+    /**
+     * If-Then-Else canónico: ite(c, t, e).
+     * Equivale a (c ∧ t) ∨ (¬c ∧ e). Implementado con descomposición
+     * Shannon directa para mejor caché.
+     */
+    ite(cond: BDDNode, thenB: BDDNode, elseB: BDDNode): BDDNode;
+    /**
+     * Cofactor de b respecto a (variable v = val).
+     * Si v no aparece o aparece más profundo, retorna b sin cambios.
+     */
+    private cofactor;
+    /**
+     * Apply algorithm de Bryant — combinador binario con memoization.
+     * Maneja AND, OR, XOR (los más usados); el resto se deriva.
+     */
+    private applyOp;
+    private memoFor;
+    private applyTerminal;
+    /** ∃v. b ≡ b[v:=0] ∨ b[v:=1] */
+    exists(v: number, b: BDDNode): BDDNode;
+    /** ∀v. b ≡ b[v:=0] ∧ b[v:=1] */
+    forall(v: number, b: BDDNode): BDDNode;
+    /**
+     * Cuenta el número de asignaciones satisfactorias sobre `numVars`.
+     * Usa bigint para soportar funciones con muchas variables.
+     */
+    satCount(b: BDDNode): bigint;
+    /**
+     * Conteo con "skip" de variables ausentes en la rama:
+     * cada variable saltada multiplica por 2.
+     */
+    private satCountAt;
+    isSatisfiable(b: BDDNode): boolean;
+    isValid(b: BDDNode): boolean;
+    /**
+     * Equivalencia estructural. Como el manager canonicaliza, basta con
+     * comparar identidad de referencias.
+     */
+    equivalent(a: BDDNode, b: BDDNode): boolean;
+    /**
+     * Evalúa b sobre una asignación `assignment[i] = valor de la var i`.
+     */
+    evaluate(b: BDDNode, assignment: boolean[]): boolean;
+    /**
+     * Construye un BDD desde CNF. Cada clausula es un array de literales
+     * en la convención DIMACS:
+     *   - literal i > 0  →  variable (i-1) positiva
+     *   - literal i < 0  →  variable (-i-1) negada
+     * El resultado es el AND de las disyunciones de cada clausula.
+     *
+     * Optimización: ordena clausulas por longitud creciente para que la
+     * unidad de propagación temprana mantenga el BDD pequeño.
+     */
+    fromCNF(clauses: number[][]): BDDNode;
+    /**
+     * Construye un BDD desde una fórmula simbólica con sintaxis libre.
+     * Soporta: `{ kind: 'var', index: number }`, `{ kind: 'true' }`,
+     * `{ kind: 'false' }`, `{ kind: 'not', child }`,
+     * `{ kind: 'and'|'or'|'xor'|'implies'|'iff', left, right }`,
+     * `{ kind: 'ite', cond, then, else }`.
+     *
+     * Si llega algo no reconocido lanza error — el formato es estricto
+     * para evitar `any` silenciosos.
+     */
+    fromFormula(formula: {
+        kind: string;
+        [k: string]: unknown;
+    }): BDDNode;
+    stats(): BDDStats;
+    /**
+     * Cuenta los nodos alcanzables desde `b` (sin contar terminales).
+     * Útil para comparar tamaños bajo distintos órdenes de variables.
+     */
+    countReachable(b: BDDNode): number;
+}
+//# sourceMappingURL=manager.d.ts.map

package/dist/bdd/manager.d.ts.map

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

package/dist/bdd/manager.js

@@ -0,0 +1,524 @@
+"use strict";
+// ============================================================
+// ROBDD — Manager con unique table + apply algorithm
+// ============================================================
+//
+// Implementación clásica de Bryant (1986):
+//   - Unique table: garantiza canonicidad estructural
+//   - Apply: combinador genérico para AND/OR/XOR/... con memoización
+//   - ITE (If-Then-Else): operador universal, reduce las binarias
+//   - Quantificadores ∃/∀ implementados sobre apply
+//   - Sat counting con bigint para evitar overflow en >53 vars
+//
+// Convención: el orden de variables se respeta en todo el DAG.
+// Si en una rama la variable de un hijo tiene índice de orden <=
+// que el padre, hay un bug — el invariante de "ordered" se mantiene
+// porque apply siempre desciende por la variable de menor orden.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BDDManager = void 0;
+const types_1 = require("./types");
+// Clave para unique table: variable + ids de hijos.
+// Para terminales usamos 'T'/'F' como id especial.
+function keyOf(variable, low, high) {
+    const lid = low.kind === 'terminal' ? (low.value ? 'T' : 'F') : `N${low.id}`;
+    const hid = high.kind === 'terminal' ? (high.value ? 'T' : 'F') : `N${high.id}`;
+    return `${variable}|${lid}|${hid}`;
+}
+function applyKey(op, a, b) {
+    const aid = a.kind === 'terminal' ? (a.value ? 'T' : 'F') : `N${a.id}`;
+    const bid = b.kind === 'terminal' ? (b.value ? 'T' : 'F') : `N${b.id}`;
+    return `${op}|${aid}|${bid}`;
+}
+function iteKey(c, t, e) {
+    const cid = c.kind === 'terminal' ? (c.value ? 'T' : 'F') : `N${c.id}`;
+    const tid = t.kind === 'terminal' ? (t.value ? 'T' : 'F') : `N${t.id}`;
+    const eid = e.kind === 'terminal' ? (e.value ? 'T' : 'F') : `N${e.id}`;
+    return `${cid}|${tid}|${eid}`;
+}
+class BDDManager {
+    numVars;
+    TRUE = { kind: 'terminal', value: true };
+    FALSE = { kind: 'terminal', value: false };
+    uniqueTable = new Map();
+    nextId = 1;
+    reductions = 0;
+    // memo caches per binary op + ite
+    memoAnd = new Map();
+    memoOr = new Map();
+    memoXor = new Map();
+    memoIte = new Map();
+    memoNot = new Map();
+    varOrder;
+    constructor(numVars) {
+        this.numVars = numVars;
+        if (numVars < 0)
+            throw new Error('BDDManager: numVars must be >= 0');
+        this.varOrder = Array.from({ length: numVars }, (_, i) => i);
+    }
+    // ----------------------------------------------------------
+    // Orden de variables
+    // ----------------------------------------------------------
+    /**
+     * Cambia el orden global de variables. Invalida memo caches porque
+     * el orden afecta la estructura de los nodos. NO reordena nodos ya
+     * construidos — si los reutilizas tras setVarOrder pueden quedar
+     * inconsistentes; recomendado para sesiones nuevas.
+     */
+    setVarOrder(order) {
+        if (order.length !== this.numVars) {
+            throw new Error(`setVarOrder: expected ${this.numVars} vars, got ${order.length}`);
+        }
+        const seen = new Set();
+        for (const v of order) {
+            if (v < 0 || v >= this.numVars) {
+                throw new Error(`setVarOrder: variable ${v} out of range`);
+            }
+            if (seen.has(v))
+                throw new Error(`setVarOrder: variable ${v} repeated`);
+            seen.add(v);
+        }
+        this.varOrder = [...order];
+        this.uniqueTable.clear();
+        this.memoAnd.clear();
+        this.memoOr.clear();
+        this.memoXor.clear();
+        this.memoIte.clear();
+        this.memoNot.clear();
+        this.nextId = 1;
+    }
+    /** Posición de la variable v dentro del orden actual (0 = top). */
+    orderPos(v) {
+        return this.varOrder.indexOf(v);
+    }
+    /** Devuelve la variable "top" de un nodo o +∞ si es terminal. */
+    topVarPos(b) {
+        if ((0, types_1.isTerminal)(b))
+            return Number.POSITIVE_INFINITY;
+        return this.orderPos(b.variable);
+    }
+    // ----------------------------------------------------------
+    // Constructores básicos
+    // ----------------------------------------------------------
+    true_() {
+        return this.TRUE;
+    }
+    false_() {
+        return this.FALSE;
+    }
+    /**
+     * Crea/recupera un nodo interno con reducción (R1) + (R2).
+     */
+    makeNode(variable, low, high) {
+        if (low === high) {
+            // R1: eliminación
+            this.reductions++;
+            return low;
+        }
+        const key = keyOf(variable, low, high);
+        const existing = this.uniqueTable.get(key);
+        if (existing) {
+            this.reductions++;
+            return existing;
+        }
+        const node = {
+            kind: 'internal',
+            variable,
+            low,
+            high,
+            id: this.nextId++,
+        };
+        this.uniqueTable.set(key, node);
+        return node;
+    }
+    /** BDD de la variable i: nodo (i, FALSE, TRUE). */
+    variable(i) {
+        if (i < 0 || i >= this.numVars) {
+            throw new Error(`variable(${i}): out of range 0..${this.numVars - 1}`);
+        }
+        return this.makeNode(i, this.FALSE, this.TRUE);
+    }
+    // ----------------------------------------------------------
+    // Operaciones
+    // ----------------------------------------------------------
+    /**
+     * Negación: implementada como ITE(b, FALSE, TRUE).
+     * Con memo dedicado para evitar recomputación.
+     */
+    not_(b) {
+        if ((0, types_1.isTerminal)(b)) {
+            return b.value ? this.FALSE : this.TRUE;
+        }
+        const key = `N${b.id}`;
+        const cached = this.memoNot.get(key);
+        if (cached)
+            return cached;
+        const result = this.makeNode(b.variable, this.not_(b.low), this.not_(b.high));
+        this.memoNot.set(key, result);
+        return result;
+    }
+    and_(a, b) {
+        return this.applyOp('and', a, b);
+    }
+    or_(a, b) {
+        return this.applyOp('or', a, b);
+    }
+    xor(a, b) {
+        return this.applyOp('xor', a, b);
+    }
+    /** A → B ≡ ¬A ∨ B */
+    implies(a, b) {
+        return this.or_(this.not_(a), b);
+    }
+    /** A ↔ B ≡ ¬(A ⊕ B) */
+    iff(a, b) {
+        return this.not_(this.xor(a, b));
+    }
+    /**
+     * If-Then-Else canónico: ite(c, t, e).
+     * Equivale a (c ∧ t) ∨ (¬c ∧ e). Implementado con descomposición
+     * Shannon directa para mejor caché.
+     */
+    ite(cond, thenB, elseB) {
+        // Casos base por terminales
+        if ((0, types_1.isTerminal)(cond))
+            return cond.value ? thenB : elseB;
+        if (thenB === elseB)
+            return thenB;
+        if ((0, types_1.isTerminal)(thenB) && (0, types_1.isTerminal)(elseB)) {
+            if (thenB.value && !elseB.value)
+                return cond;
+            if (!thenB.value && elseB.value)
+                return this.not_(cond);
+        }
+        const key = iteKey(cond, thenB, elseB);
+        const cached = this.memoIte.get(key);
+        if (cached)
+            return cached;
+        // Variable top: la de menor posición entre las tres
+        const pc = this.topVarPos(cond);
+        const pt = this.topVarPos(thenB);
+        const pe = this.topVarPos(elseB);
+        const top = Math.min(pc, pt, pe);
+        const v = this.varOrder[top];
+        const condLow = this.cofactor(cond, v, false);
+        const condHigh = this.cofactor(cond, v, true);
+        const thenLow = this.cofactor(thenB, v, false);
+        const thenHigh = this.cofactor(thenB, v, true);
+        const elseLow = this.cofactor(elseB, v, false);
+        const elseHigh = this.cofactor(elseB, v, true);
+        const low = this.ite(condLow, thenLow, elseLow);
+        const high = this.ite(condHigh, thenHigh, elseHigh);
+        const result = this.makeNode(v, low, high);
+        this.memoIte.set(key, result);
+        return result;
+    }
+    /**
+     * Cofactor de b respecto a (variable v = val).
+     * Si v no aparece o aparece más profundo, retorna b sin cambios.
+     */
+    cofactor(b, v, val) {
+        if ((0, types_1.isTerminal)(b))
+            return b;
+        const pb = this.orderPos(b.variable);
+        const pv = this.orderPos(v);
+        if (pb > pv)
+            return b; // v viene antes que b.variable en el orden → b no depende
+        if (b.variable === v) {
+            return val ? b.high : b.low;
+        }
+        // pb < pv: b depende de algo más alto; descender
+        const low = this.cofactor(b.low, v, val);
+        const high = this.cofactor(b.high, v, val);
+        return this.makeNode(b.variable, low, high);
+    }
+    /**
+     * Apply algorithm de Bryant — combinador binario con memoization.
+     * Maneja AND, OR, XOR (los más usados); el resto se deriva.
+     */
+    applyOp(op, a, b) {
+        // Terminales
+        const term = this.applyTerminal(op, a, b);
+        if (term)
+            return term;
+        const memo = this.memoFor(op);
+        const key = applyKey(op, a, b);
+        const cached = memo.get(key);
+        if (cached)
+            return cached;
+        // Variable top
+        const pa = this.topVarPos(a);
+        const pb = this.topVarPos(b);
+        const top = Math.min(pa, pb);
+        const v = this.varOrder[top];
+        const aLow = this.cofactor(a, v, false);
+        const aHigh = this.cofactor(a, v, true);
+        const bLow = this.cofactor(b, v, false);
+        const bHigh = this.cofactor(b, v, true);
+        const low = this.applyOp(op, aLow, bLow);
+        const high = this.applyOp(op, aHigh, bHigh);
+        const result = this.makeNode(v, low, high);
+        memo.set(key, result);
+        return result;
+    }
+    memoFor(op) {
+        if (op === 'and')
+            return this.memoAnd;
+        if (op === 'or')
+            return this.memoOr;
+        return this.memoXor;
+    }
+    applyTerminal(op, a, b) {
+        // Cortocircuitos
+        if (op === 'and') {
+            if (a === this.FALSE || b === this.FALSE)
+                return this.FALSE;
+            if (a === this.TRUE)
+                return b;
+            if (b === this.TRUE)
+                return a;
+            if (a === b)
+                return a;
+        }
+        else if (op === 'or') {
+            if (a === this.TRUE || b === this.TRUE)
+                return this.TRUE;
+            if (a === this.FALSE)
+                return b;
+            if (b === this.FALSE)
+                return a;
+            if (a === b)
+                return a;
+        }
+        else {
+            // xor
+            if (a === this.FALSE)
+                return b;
+            if (b === this.FALSE)
+                return a;
+            if (a === this.TRUE)
+                return this.not_(b);
+            if (b === this.TRUE)
+                return this.not_(a);
+            if (a === b)
+                return this.FALSE;
+        }
+        if ((0, types_1.isTerminal)(a) && (0, types_1.isTerminal)(b)) {
+            const av = a.value;
+            const bv = b.value;
+            let r;
+            if (op === 'and')
+                r = av && bv;
+            else if (op === 'or')
+                r = av || bv;
+            else
+                r = av !== bv;
+            return r ? this.TRUE : this.FALSE;
+        }
+        return undefined;
+    }
+    // ----------------------------------------------------------
+    // Cuantificadores
+    // ----------------------------------------------------------
+    /** ∃v. b ≡ b[v:=0] ∨ b[v:=1] */
+    exists(v, b) {
+        if (v < 0 || v >= this.numVars)
+            throw new Error(`exists: var ${v} out of range`);
+        const c0 = this.cofactor(b, v, false);
+        const c1 = this.cofactor(b, v, true);
+        return this.or_(c0, c1);
+    }
+    /** ∀v. b ≡ b[v:=0] ∧ b[v:=1] */
+    forall(v, b) {
+        if (v < 0 || v >= this.numVars)
+            throw new Error(`forall: var ${v} out of range`);
+        const c0 = this.cofactor(b, v, false);
+        const c1 = this.cofactor(b, v, true);
+        return this.and_(c0, c1);
+    }
+    // ----------------------------------------------------------
+    // Queries
+    // ----------------------------------------------------------
+    /**
+     * Cuenta el número de asignaciones satisfactorias sobre `numVars`.
+     * Usa bigint para soportar funciones con muchas variables.
+     */
+    satCount(b) {
+        return this.satCountAt(b, 0);
+    }
+    /**
+     * Conteo con "skip" de variables ausentes en la rama:
+     * cada variable saltada multiplica por 2.
+     */
+    satCountAt(b, depth) {
+        if ((0, types_1.isTerminal)(b)) {
+            if (!b.value)
+                return 0n;
+            // Todas las variables restantes son libres: 2^(numVars - depth)
+            const skipped = BigInt(this.numVars - depth);
+            return 1n << skipped;
+        }
+        const pos = this.orderPos(b.variable);
+        // Variables entre depth y pos están skipped → 2^(pos - depth)
+        const skipped = BigInt(pos - depth);
+        const factor = 1n << skipped;
+        const low = this.satCountAt(b.low, pos + 1);
+        const high = this.satCountAt(b.high, pos + 1);
+        return factor * (low + high);
+    }
+    isSatisfiable(b) {
+        return b !== this.FALSE;
+    }
+    isValid(b) {
+        return b === this.TRUE;
+    }
+    /**
+     * Equivalencia estructural. Como el manager canonicaliza, basta con
+     * comparar identidad de referencias.
+     */
+    equivalent(a, b) {
+        return a === b;
+    }
+    /**
+     * Evalúa b sobre una asignación `assignment[i] = valor de la var i`.
+     */
+    evaluate(b, assignment) {
+        if (assignment.length < this.numVars) {
+            throw new Error(`evaluate: assignment length ${assignment.length} < numVars ${this.numVars}`);
+        }
+        let cur = b;
+        while (!(0, types_1.isTerminal)(cur)) {
+            const v = cur.variable;
+            const val = assignment[v];
+            if (val === undefined) {
+                throw new Error(`evaluate: missing assignment for var ${v}`);
+            }
+            cur = val ? cur.high : cur.low;
+        }
+        return cur.value;
+    }
+    // ----------------------------------------------------------
+    // Conversión desde CNF / fórmulas
+    // ----------------------------------------------------------
+    /**
+     * Construye un BDD desde CNF. Cada clausula es un array de literales
+     * en la convención DIMACS:
+     *   - literal i > 0  →  variable (i-1) positiva
+     *   - literal i < 0  →  variable (-i-1) negada
+     * El resultado es el AND de las disyunciones de cada clausula.
+     *
+     * Optimización: ordena clausulas por longitud creciente para que la
+     * unidad de propagación temprana mantenga el BDD pequeño.
+     */
+    fromCNF(clauses) {
+        if (clauses.length === 0)
+            return this.TRUE;
+        // Validación de literales
+        for (const cl of clauses) {
+            for (const lit of cl) {
+                if (lit === 0)
+                    throw new Error('fromCNF: literal 0 not allowed (DIMACS)');
+                const v = Math.abs(lit) - 1;
+                if (v >= this.numVars) {
+                    throw new Error(`fromCNF: literal ${lit} exceeds numVars ${this.numVars}`);
+                }
+            }
+        }
+        // Ordenar clausulas: cortas primero (más restrictivas)
+        const ordered = [...clauses].sort((a, b) => a.length - b.length);
+        let acc = this.TRUE;
+        for (const clause of ordered) {
+            let disj = this.FALSE;
+            for (const lit of clause) {
+                const v = Math.abs(lit) - 1;
+                const x = this.variable(v);
+                const litBdd = lit > 0 ? x : this.not_(x);
+                disj = this.or_(disj, litBdd);
+            }
+            acc = this.and_(acc, disj);
+            if (acc === this.FALSE)
+                return acc; // cortocircuito UNSAT
+        }
+        return acc;
+    }
+    /**
+     * Construye un BDD desde una fórmula simbólica con sintaxis libre.
+     * Soporta: `{ kind: 'var', index: number }`, `{ kind: 'true' }`,
+     * `{ kind: 'false' }`, `{ kind: 'not', child }`,
+     * `{ kind: 'and'|'or'|'xor'|'implies'|'iff', left, right }`,
+     * `{ kind: 'ite', cond, then, else }`.
+     *
+     * Si llega algo no reconocido lanza error — el formato es estricto
+     * para evitar `any` silenciosos.
+     */
+    fromFormula(formula) {
+        const k = formula.kind;
+        if (k === 'true')
+            return this.TRUE;
+        if (k === 'false')
+            return this.FALSE;
+        if (k === 'var') {
+            const idx = formula.index;
+            if (typeof idx !== 'number')
+                throw new Error('fromFormula: var.index must be number');
+            return this.variable(idx);
+        }
+        if (k === 'not') {
+            const child = formula.child;
+            return this.not_(this.fromFormula(child));
+        }
+        if (k === 'and' || k === 'or' || k === 'xor' || k === 'implies' || k === 'iff') {
+            const left = formula.left;
+            const right = formula.right;
+            const L = this.fromFormula(left);
+            const R = this.fromFormula(right);
+            if (k === 'and')
+                return this.and_(L, R);
+            if (k === 'or')
+                return this.or_(L, R);
+            if (k === 'xor')
+                return this.xor(L, R);
+            if (k === 'implies')
+                return this.implies(L, R);
+            return this.iff(L, R);
+        }
+        if (k === 'ite') {
+            const c = formula.cond;
+            const t = formula.then;
+            const e = formula.else;
+            return this.ite(this.fromFormula(c), this.fromFormula(t), this.fromFormula(e));
+        }
+        throw new Error(`fromFormula: unknown kind "${k}"`);
+    }
+    // ----------------------------------------------------------
+    // Stats / introspección
+    // ----------------------------------------------------------
+    stats() {
+        return {
+            nodes: this.uniqueTable.size,
+            reductions: this.reductions,
+        };
+    }
+    /**
+     * Cuenta los nodos alcanzables desde `b` (sin contar terminales).
+     * Útil para comparar tamaños bajo distintos órdenes de variables.
+     */
+    countReachable(b) {
+        const seen = new Set();
+        const stack = [b];
+        while (stack.length > 0) {
+            const cur = stack.pop();
+            if (cur === undefined)
+                break;
+            if ((0, types_1.isTerminal)(cur))
+                continue;
+            if (seen.has(cur.id))
+                continue;
+            seen.add(cur.id);
+            stack.push(cur.low);
+            stack.push(cur.high);
+        }
+        return seen.size;
+    }
+}
+exports.BDDManager = BDDManager;
+//# sourceMappingURL=manager.js.map