binary-decision-diagram 4.0.0 → 5.0.0

package/dist/esm/src/ordering/optimize-ordering.js

@@ -0,0 +1,399 @@
+import { parseTruthTable, denseTruthTableToMap, ensureValidOrdering } from './dense-truth-table.js';
+import { OrderingEvaluator } from './ordering-evaluator.js';
+import { LocalOrderingSearch, seedOrderings, DEFAULT_WINDOW_SIZE, ensureWindowSize, ensureNonNegativeInteger } from './local-search.js';
+import { ExactOrderingSearch } from './exact-ordering.js';
+import { ExactCostOrderingSearch } from './exact-cost-ordering.js';
+import { buildBddFromDiagram } from './build-bdd.js';
+export const DEFAULT_MAX_EXACT_VARIABLES = 20;
+export const DEFAULT_MAX_EXACT_NODE_COUNT = 5000;
+/**
+ * Validates functionCosts and rowWeight and turns them into a cost model.
+ */
+export function buildCostModel(table, functionCosts, rowWeight) {
+    if (!functionCosts) {
+        if (rowWeight) {
+            throw new Error('rowWeight can only be used together with functionCosts');
+        }
+        return null;
+    }
+    const n = table.variableCount;
+    if (functionCosts.length !== n) {
+        throw new Error('functionCosts must have one entry per boolean function (' + n + ')');
+    }
+    const costs = new Float64Array(n);
+    for (let v = 0; v < n; v++) {
+        const cost = functionCosts[v];
+        if (typeof cost !== 'number' || !isFinite(cost) || cost < 0) {
+            throw new Error('functionCosts[' + v + '] must be a non-negative number');
+        }
+        costs[v] = cost;
+    }
+    const weights = new Float64Array(table.rowCount);
+    let totalWeight = 0;
+    for (let row = 0; row < table.rowCount; row++) {
+        const id = table.terminalIds[row];
+        if (id === table.dontCareTerminal) {
+            continue;
+        }
+        let weight = 1;
+        if (rowWeight) {
+            const key = row.toString(2).padStart(n, '0');
+            weight = rowWeight(key, table.terminalValues[id]);
+            if (typeof weight !== 'number' || !isFinite(weight) || weight < 0) {
+                throw new Error('rowWeight must return a non-negative number, got ' + weight + ' for ' + key);
+            }
+        }
+        weights[row] = weight;
+        totalWeight += weight;
+    }
+    if (totalWeight <= 0) {
+        throw new Error('all row weights are zero');
+    }
+    let maxCost = 0;
+    costs.forEach(cost => maxCost = Math.max(maxCost, cost));
+    if (!isFinite(totalWeight) || !isFinite(maxCost * totalWeight)) {
+        throw new Error('the function costs or row weights are too large, scale them down');
+    }
+    return {
+        functionCosts: costs,
+        rowWeights: weights,
+        totalWeight
+    };
+}
+/**
+ * Deterministically finds a variable ordering with a small BDD
+ * (or, with functionCosts, with a cheap resolve() call).
+ * See docs/variable-ordering.md for how it works.
+ * Does not create BDD nodes, use optimizeOrdering() for that.
+ */
+export function findOrdering(input) {
+    return findOrderingWithTable(input).result;
+}
+/**
+ * Checks the options before any expensive work starts.
+ */
+function ensureValidOptions(input) {
+    if (input.windowSize !== undefined) {
+        ensureWindowSize(input.windowSize);
+    }
+    if (input.maxRounds !== undefined) {
+        ensureNonNegativeInteger(input.maxRounds, 'maxRounds');
+    }
+    const budgets = ['maxExactVariables', 'maxExactNodeCount', 'maxExactExpansions', 'maxExactDiagramNodes'];
+    budgets.forEach(name => {
+        const value = input[name];
+        if (value !== undefined) {
+            ensureNonNegativeInteger(value, name);
+        }
+    });
+    if (input.exact !== undefined && input.exact !== true && input.exact !== false && input.exact !== 'auto') {
+        throw new Error('exact must be true, false or \'auto\'');
+    }
+}
+function findOrderingWithTable(input) {
+    const startTime = Date.now();
+    ensureValidOptions(input);
+    const log = input.log ? (message) => console.log('findOrdering(): ' + message) : () => null;
+    const onImprovement = input.onImprovement ? input.onImprovement : () => null;
+    const base = parseTruthTable(input.truthTable, input.dontCareValue);
+    const n = base.variableCount;
+    const costModel = buildCostModel(base, input.functionCosts, input.rowWeight);
+    const baseEvaluator = new OrderingEvaluator(base, costModel);
+    const windowSize = input.windowSize === undefined ? DEFAULT_WINDOW_SIZE : input.windowSize;
+    let evaluations = 0;
+    const describe = (evaluation) => evaluation.nodeCount + ' nodes' +
+        (costModel ? ', expected cost ' + evaluation.expectedCost : '');
+    /**
+     * phase 1: deterministic seeds, each improved by sifting and window permutation
+     */
+    const userSeeds = (input.initialOrderings ? input.initialOrderings : []).map((ordering, index) => {
+        ensureValidOrdering(ordering, n);
+        return { name: 'initial-' + index, ordering: Array.from(ordering) };
+    });
+    const seenSeeds = new Set();
+    const seeds = userSeeds.concat(seedOrderings(baseEvaluator)).filter(seed => {
+        const key = seed.ordering.join(',');
+        if (seenSeeds.has(key)) {
+            return false;
+        }
+        seenSeeds.add(key);
+        return true;
+    });
+    let localBest = null;
+    const seedResults = [];
+    // the last evaluation passed to onImprovement
+    const reported = { evaluation: null };
+    for (const seed of seeds) {
+        const search = new LocalOrderingSearch(baseEvaluator, seed.ordering, {
+            windowSize,
+            maxRounds: input.maxRounds,
+            log: message => log('[' + seed.name + '] ' + message),
+            onImprovement: progress => {
+                if (!localBest || baseEvaluator.isBetter(search.best, localBest.evaluation)) {
+                    reported.evaluation = search.best;
+                    onImprovement(progress);
+                }
+            }
+        });
+        const result = search.run();
+        log('seed ' + seed.name + ': ' + describe(result.evaluation));
+        seedResults.push({ ordering: result.ordering, evaluation: result.evaluation });
+        if (!localBest || baseEvaluator.isBetter(result.evaluation, localBest.evaluation)) {
+            localBest = { ordering: result.ordering, evaluation: result.evaluation };
+            if (!reported.evaluation || baseEvaluator.isBetter(result.evaluation, reported.evaluation)) {
+                // the seed itself was better than everything before, the search did not report it
+                reported.evaluation = result.evaluation;
+                onImprovement({
+                    ordering: result.ordering.slice(),
+                    nodeCount: result.evaluation.nodeCount,
+                    expectedCost: result.evaluation.expectedCost,
+                    phase: 'seed'
+                });
+            }
+        }
+    }
+    if (!localBest) {
+        throw new Error('no ordering found, this should not happen');
+    }
+    let best = localBest;
+    const localSearchNodeCount = best.evaluation.nodeCount;
+    /**
+     * phase 2: exact search
+     *
+     * The exact search needs a fully specified function, so it runs on the
+     * truth table with the don't-care rows resolved. Different orderings resolve
+     * them differently, so every completion the local search came across is a
+     * candidate. Whenever a new best ordering is found, its own completion
+     * becomes a candidate too.
+     */
+    let completed = baseEvaluator.complete(best.ordering);
+    let optimal = false;
+    let exactExpansions = 0;
+    const exactMode = input.exact === undefined ? 'auto' : input.exact;
+    const maxExactVariables = input.maxExactVariables === undefined ? DEFAULT_MAX_EXACT_VARIABLES : input.maxExactVariables;
+    const maxExactNodeCount = input.maxExactNodeCount === undefined ? DEFAULT_MAX_EXACT_NODE_COUNT : input.maxExactNodeCount;
+    const runExact = exactMode === true || (exactMode === 'auto' &&
+        n <= maxExactVariables &&
+        best.evaluation.internalNodeCount <= maxExactNodeCount);
+    if (exactMode === 'auto' && !runExact) {
+        log('exact search skipped: ' + n + ' boolean functions, ' + best.evaluation.internalNodeCount + ' internal nodes');
+    }
+    if (runExact) {
+        const candidates = [];
+        const seenCompletions = new Set();
+        const addCandidate = (ordering, front) => {
+            const table = baseEvaluator.complete(ordering);
+            const key = completionKey(table);
+            if (seenCompletions.has(key)) {
+                return;
+            }
+            seenCompletions.add(key);
+            const candidate = { ordering, table };
+            if (front) {
+                candidates.unshift(candidate);
+            }
+            else {
+                candidates.push(candidate);
+            }
+        };
+        addCandidate(best.ordering, false);
+        if (base.dontCareTerminal >= 0) {
+            seedResults.forEach(result => addCandidate(result.ordering, false));
+        }
+        /**
+         * completions for which the exact search finished: on them, no ordering
+         * beats the best evaluation known at that time (which is never worse than
+         * the final one)
+         */
+        const solvedCompletions = new Set();
+        while (candidates.length > 0) {
+            const candidate = candidates.shift();
+            const candidateKey = completionKey(candidate.table);
+            let exactOrdering;
+            let solved;
+            let expansions;
+            const searchOptions = { maxDiagramNodes: input.maxExactDiagramNodes };
+            if (costModel) {
+                const exactResult = new ExactCostOrderingSearch(candidate.table, costModel, searchOptions).run({
+                    maxExpansions: input.maxExactExpansions,
+                    upperBoundOrdering: candidate.ordering,
+                    // only orderings that beat the best known one are interesting
+                    upperBound: best.evaluation.expectedCost,
+                    log
+                });
+                exactOrdering = exactResult.ordering;
+                solved = exactResult.solved;
+                expansions = exactResult.expansions;
+            }
+            else {
+                const exactResult = new ExactOrderingSearch(candidate.table, searchOptions).run({
+                    maxExpansions: input.maxExactExpansions,
+                    upperBoundOrdering: candidate.ordering,
+                    upperBound: best.evaluation.nodeCount - candidate.table.leafCount,
+                    log
+                });
+                exactOrdering = exactResult.ordering;
+                solved = exactResult.solved;
+                expansions = exactResult.expansions;
+            }
+            exactExpansions += expansions;
+            if (!solved) {
+                log('exact search gave up on one completion of the truth table');
+                continue;
+            }
+            solvedCompletions.add(candidateKey);
+            if (!exactOrdering) {
+                continue;
+            }
+            const candidateEvaluator = new OrderingEvaluator(candidate.table, costModel);
+            let exactEvaluation = candidateEvaluator.evaluate(exactOrdering);
+            if (costModel) {
+                /**
+                 * The exact cost search only minimizes the expected cost. Among the
+                 * orderings with the same cost, fewer nodes are better, which the
+                 * local search on the same completion takes care of.
+                 */
+                const polished = new LocalOrderingSearch(candidateEvaluator, exactOrdering, {
+                    windowSize,
+                    maxRounds: input.maxRounds
+                }).run();
+                exactOrdering = polished.ordering;
+                exactEvaluation = polished.evaluation;
+            }
+            evaluations += candidateEvaluator.evaluations;
+            log('exact search: ' + describe(exactEvaluation) + ' after ' + expansions + ' expansions');
+            if (baseEvaluator.isBetter(exactEvaluation, best.evaluation)) {
+                best = { ordering: exactOrdering, evaluation: exactEvaluation };
+                completed = candidate.table;
+                onImprovement({
+                    ordering: best.ordering.slice(),
+                    nodeCount: exactEvaluation.nodeCount,
+                    expectedCost: exactEvaluation.expectedCost,
+                    phase: 'exact'
+                });
+                if (base.dontCareTerminal >= 0) {
+                    // the don't-care rows might resolve even better with the new ordering
+                    addCandidate(best.ordering, true);
+                }
+            }
+        }
+        /**
+         * When the completion the ordering picks itself is just as good,
+         * prefer it: then createBddWithOrdering(input, ordering, dontCareValue)
+         * rebuilds the same BDD.
+         */
+        if (base.dontCareTerminal >= 0) {
+            const own = baseEvaluator.complete(best.ordering);
+            if (completionKey(own) !== completionKey(completed)) {
+                const ownEvaluation = baseEvaluator.evaluate(best.ordering);
+                if (baseEvaluator.compare(ownEvaluation, best.evaluation) === 0) {
+                    best = { ordering: best.ordering, evaluation: ownEvaluation };
+                    completed = own;
+                }
+            }
+        }
+        optimal = solvedCompletions.has(completionKey(completed));
+    }
+    evaluations += baseEvaluator.evaluations;
+    return {
+        result: {
+            ordering: best.ordering,
+            nodeCount: best.evaluation.nodeCount,
+            expectedCost: costModel ? best.evaluation.expectedCost : undefined,
+            optimal,
+            truthTable: denseTruthTableToMap(completed),
+            stats: {
+                evaluations,
+                exactExpansions,
+                localSearchNodeCount,
+                durationMs: Date.now() - startTime
+            }
+        },
+        table: completed
+    };
+}
+/**
+ * identifies the content of a (completed) table
+ */
+function completionKey(table) {
+    let h1 = 0x811C9DC5;
+    let h2 = 0x01000193;
+    const ids = table.terminalIds;
+    for (let i = 0; i < ids.length; i++) {
+        h1 = Math.imul(h1 ^ ids[i], 0x01000193);
+        h2 = Math.imul(h2 + ids[i], 0x9E3779B1) ^ (h2 >>> 13);
+    }
+    return (h1 >>> 0).toString(16) + ':' + (h2 >>> 0).toString(16) + ':' + ids.length;
+}
+/**
+ * Deterministic replacement for optimizeBruteForce():
+ * finds a good variable ordering and returns the minimized BDD for it.
+ * All work is synchronous, the promise exists for compatibility with optimizeBruteForce().
+ */
+export async function optimizeOrdering(input) {
+    const { result: found, table } = findOrderingWithTable(input);
+    const bdd = buildBddForOrdering(table, found.ordering);
+    let optimal = found.optimal;
+    if (input.afterBddCreation) {
+        const before = fingerprint(bdd);
+        input.afterBddCreation(bdd);
+        bdd.minimize();
+        if (fingerprint(bdd) !== before) {
+            // the hook changed the BDD, the proof does not hold for it anymore
+            optimal = false;
+        }
+    }
+    return {
+        bdd,
+        ordering: found.ordering,
+        nodeCount: bdd.countNodes(),
+        expectedCost: found.expectedCost,
+        optimal,
+        truthTable: found.truthTable,
+        stats: found.stats
+    };
+}
+/**
+ * Describes the structure and the leaf values of a BDD,
+ * equal BDDs give equal strings.
+ */
+function fingerprint(bdd) {
+    const ids = new Map();
+    const parts = [];
+    const visit = (node) => {
+        const known = ids.get(node);
+        if (known !== undefined) {
+            return known;
+        }
+        let part;
+        if (node.isLeafNode()) {
+            part = 'v' + String(node.asLeafNode().value);
+        }
+        else {
+            const branches = node.branches;
+            part = node.level + ':' + visit(branches.getBranch('0')) + ',' + visit(branches.getBranch('1'));
+        }
+        const id = parts.length;
+        parts.push(part);
+        ids.set(node, id);
+        return id;
+    };
+    visit(bdd);
+    return parts.join(';');
+}
+/**
+ * Creates the minimized BDD of a truth table for a given ordering
+ * without going through the unreduced decision tree.
+ */
+export function createBddWithOrdering(truthTable, ordering, dontCareValue) {
+    const base = parseTruthTable(truthTable, dontCareValue);
+    const evaluator = new OrderingEvaluator(base);
+    const completed = evaluator.complete(ordering);
+    return buildBddForOrdering(completed, ordering);
+}
+function buildBddForOrdering(table, ordering) {
+    const evaluator = new OrderingEvaluator(table);
+    const diagram = evaluator.buildDiagram(ordering);
+    return buildBddFromDiagram(diagram, table);
+}
+//# sourceMappingURL=optimize-ordering.js.map

package/dist/esm/src/ordering/optimize-ordering.js.map

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

package/dist/esm/src/ordering/ordering-evaluator.d.ts

@@ -0,0 +1,198 @@
+import type { DenseTruthTable } from './dense-truth-table.js';
+/**
+ * Describes what a resolve() call costs.
+ */
+export interface CostModel {
+    /** functionCosts[v] = cost of calling boolean function v */
+    functionCosts: Float64Array;
+    /**
+     * rowWeights[row] = how often the row occurs at runtime, relative to the other rows.
+     * Must be 0 for don't-care rows, they never occur.
+     */
+    rowWeights: Float64Array;
+    /** sum of rowWeights */
+    totalWeight: number;
+}
+/**
+ * Result of evaluating a variable ordering.
+ */
+export interface OrderingEvaluation {
+    /**
+     * nodesPerLevel[k] is the amount of nodes of the reduced BDD
+     * that test the boolean function ordering[k].
+     */
+    nodesPerLevel: number[];
+    /** sum of nodesPerLevel */
+    internalNodeCount: number;
+    /**
+     * Amount of nodes as RootNode.countNodes() would return it:
+     * the root node, plus all nodes below the top level, plus the leaf nodes.
+     */
+    nodeCount: number;
+    /**
+     * Expected cost of one resolve() call: the costs of the boolean functions
+     * that are called on the way from the root to the leaf, averaged over the
+     * rows with their weights. 0 when the evaluator has no cost model.
+     */
+    expectedCost: number;
+}
+/**
+ * A reduced ordered (multi terminal) decision diagram
+ * in a flat array representation. Ids below terminalCount are terminals
+ * (and equal the terminal id of the dense truth table), ids from terminalCount
+ * on are internal nodes: node i is stored at index (i - terminalCount).
+ */
+export interface ReducedDiagram {
+    variableCount: number;
+    terminalCount: number;
+    /** id of the root, can be a terminal when the function is constant */
+    root: number;
+    /** level (index into the ordering) of each internal node */
+    nodeLevel: Int32Array;
+    /** id of the 0-branch of each internal node */
+    nodeLo: Int32Array;
+    /** id of the 1-branch of each internal node */
+    nodeHi: Int32Array;
+    /** ordering[level] = boolean function tested on that level */
+    ordering: number[];
+    nodesPerLevel: number[];
+}
+interface DiagramRecord {
+    nodeLevel: Int32Array;
+    nodeLo: Int32Array;
+    nodeHi: Int32Array;
+}
+/**
+ * relative tolerance for comparing expected costs
+ */
+export declare const COST_EPSILON = 1e-9;
+/**
+ * Two costs closer than this are treated as equal. The tolerance is relative
+ * to the larger of the value and the cost of one call of the most expensive
+ * boolean function (`unit`), so it does not depend on the unit the
+ * functionCosts are given in (milliseconds, seconds, ...).
+ */
+export declare function costTolerance(value: number, unit: number): number;
+/**
+ * The cost of one call of the most expensive boolean function,
+ * the unit of costTolerance() for expected costs.
+ */
+export declare function costUnit(costModel: CostModel): number;
+/**
+ * An ordering together with the intermediate results of its evaluation.
+ *
+ * levelIds[L] holds the ids of the 2^L blocks of level L (levelIds[n] are the
+ * rows of the truth table). Because blocks are indexed by the natural
+ * assignment to the functions above their level, swapping the functions of two
+ * levels keeps all levels below the lower one valid, only the levels from the
+ * lower one up to the root are recomputed.
+ */
+export declare class OrderingCursor {
+    private readonly evaluator;
+    private readonly record;
+    readonly ordering: number[];
+    evaluation: OrderingEvaluation;
+    /** id of the root block, a terminal when the function is constant */
+    root: number;
+    private readonly n;
+    private readonly levelIds;
+    private readonly levelWeights;
+    private readonly created;
+    private readonly payingWeights;
+    constructor(evaluator: OrderingEvaluator, ordering: ArrayLike<number>, record?: DiagramRecord | null);
+    /**
+     * Starts over with another ordering.
+     */
+    reset(ordering: ArrayLike<number>): void;
+    /**
+     * Swaps the boolean functions of two levels and updates the evaluation.
+     */
+    swap(levelA: number, levelB: number): void;
+    /**
+     * recomputes the levels top .. 0 (the levels below stay as they are)
+     */
+    private recomputeFrom;
+}
+/**
+ * Evaluates variable orderings of a truth table without ever creating
+ * BDD node objects.
+ *
+ * The reduced BDD is built bottom-up: the rows of the truth table are the
+ * leaves, every level above merges the two children of each block into a node
+ * through a hash table (hash-consing). Equal children collapse to a single edge
+ * (reduction rule) and equal (child0, child1) pairs share one node (elimination
+ * rule), so the amount of nodes created per level is exactly the amount of
+ * nodes the reduced BDD has on that level. Everything runs in O(2^n) integer
+ * operations.
+ *
+ * A block on level L is the set of rows that agree on the boolean functions
+ * above level L. Blocks are indexed by the assignment to those functions in
+ * their natural (index) order, not in the order of the levels. That way the
+ * blocks of a level only depend on the SET of functions above it: when two
+ * levels swap their functions, nothing below them changes and OrderingCursor
+ * only recomputes the levels above.
+ *
+ * Don't-care rows are handled like RootNode.removeIrrelevantLeafNodes() does it:
+ * a node whose one branch is entirely don't-care is replaced by its other branch.
+ *
+ * With a cost model, the same pass also sums up the weight of the rows that
+ * pass through a node on each level, which gives the expected cost of a
+ * resolve() call: a row pays for the boolean function of a level exactly when
+ * its block on that level has a node. The root node always calls its boolean
+ * function, even when the function is irrelevant.
+ */
+export declare class OrderingEvaluator {
+    readonly table: DenseTruthTable;
+    readonly costModel: CostModel | null;
+    readonly variableCount: number;
+    readonly rowCount: number;
+    readonly terminalCount: number;
+    readonly dontCare: number;
+    /** amount of evaluations run so far */
+    evaluations: number;
+    private readonly hashLo;
+    private readonly hashHi;
+    private readonly hashId;
+    private scratch;
+    private costUnit;
+    constructor(table: DenseTruthTable, costModel?: CostModel | null);
+    /**
+     * Evaluates an ordering.
+     */
+    evaluate(ordering: ArrayLike<number>): OrderingEvaluation;
+    /**
+     * A cursor keeps the intermediate results of an ordering so that
+     * swapping two levels only recomputes the levels above them.
+     */
+    cursor(ordering: ArrayLike<number>): OrderingCursor;
+    /**
+     * @returns true when evaluation a is strictly better than b:
+     * fewer nodes, or with a cost model a lower expected cost
+     * (ties in the expected cost are broken by the amount of nodes)
+     */
+    isBetter(a: OrderingEvaluation, b: OrderingEvaluation): boolean;
+    /**
+     * negative when a is better than b, positive when b is better, 0 when equal
+     */
+    compare(a: OrderingEvaluation, b: OrderingEvaluation): number;
+    /**
+     * Builds the reduced diagram of an ordering.
+     */
+    buildDiagram(ordering: ArrayLike<number>): ReducedDiagram;
+    /**
+     * Resolves the don't-care rows the same way the BDD of the given ordering
+     * resolves them (a don't-care branch takes the value of its sibling branch)
+     * and returns a table without don't-care rows.
+     * When the table has no don't-care rows, the same table is returned.
+     */
+    complete(ordering: ArrayLike<number>): DenseTruthTable;
+    /**
+     * Computes the blocks of one level out of the blocks of the level below.
+     * @internal
+     */
+    computeLevel(ordering: number[], level: number, deeperIds: Int32Array, deeperWeights: Float64Array | null, ids: Int32Array, weights: Float64Array | null, firstId: number, record: DiagramRecord | null): {
+        created: number;
+        payingWeight: number;
+    };
+}
+export {};