PySDD 1.0.6__cp314-cp314-win32.whl

pysdd/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

pysdd/__main__.py

@@ -0,0 +1,19 @@
+# -*- coding: UTF-8 -*-
+"""
+pysdd.__main__
+~~~~~~~~~~~~~~
+
+Command Line Interface.
+
+Will be run when `python -m pysdd` is used.
+
+:author: Wannes Meert, Arthur Choi
+:copyright: Copyright 2017-2019 KU Leuven and Regents of the University of California.
+:license: Apache License, Version 2.0, see LICENSE for details.
+
+"""
+from .cli import main
+
+
+if __name__ == "__main__":
+    main()

pysdd/cli.py

@@ -0,0 +1,261 @@
+#!/usr/bin/env python3
+# encoding: utf-8
+"""
+pysdd-cli
+~~~~~~~~~
+
+PySDD command line interface.
+
+:author: Wannes Meert, Arthur Choi
+:copyright: Copyright 2019 KU Leuven and Regents of the University of California.
+:license: Apache License, Version 2.0, see LICENSE for details.
+"""
+from pathlib import Path
+import sys
+import time
+import argparse
+import logging
+from .sdd import SddManager, Vtree, Fnf, CompilerOptions
+
+
+logger = logging.getLogger(__name__)
+
+
+def main(argv=None):
+    options, args = getopt(argv)
+    fnf = None
+    weights = None
+
+    if options.cnf_filename is not None:
+        print("reading cnf...")
+        fnf = Fnf.from_cnf_file(bytes(options.cnf_filename))
+        weights = read_weights(options.cnf_filename)
+    elif options.dnf_filename is not None:
+        print("reading dnf...")
+        fnf = Fnf.from_dnf_file(bytes(options.dnf_filename))
+        weights = read_weights(options.dnf_filename)
+
+    if options.vtree_filename is not None:
+        print("reading initial vtree...")
+        vtree = Vtree.from_file(bytes(options.vtree_filename))
+    else:
+        if fnf is None:
+            raise argparse.ArgumentTypeError("CNF or DNF file required")
+        print(f"creating initial vtree {options.initial_vtree_type.decode()}")
+        vtree = Vtree(var_count=fnf.var_count, vtree_type=options.initial_vtree_type)
+
+    print("creating manager...")
+    manager = SddManager.from_vtree(vtree)
+    manager.set_options(options)
+
+    if options.sdd_filename is None:
+        print("compiling...")
+        c1 = time.time()
+        node = manager.fnf_to_sdd(fnf)
+        c2 = time.time()
+        secs = c2 - c1
+        print("")
+        print(f"compilation time         : {secs:.3f} sec")
+    else:
+        print("reading sdd from file...")
+        c1 = time.time()
+        node = manager.read_sdd_file(options.sdd_filename)
+        c2 = time.time()
+        secs = c2 - c1
+        print(f"read time                : {secs:.3f} sec")
+        weights = read_weights(options.sdd_filename)
+
+    wmc = create_wmc(node, weights, args)
+
+    print_node(node, wmc)
+    if options.verbose:
+        manager.print_stdout()
+
+    if options.minimize_cardinality:
+        print("\nminimizing cardinality...", end="")
+        c1 = time.time()
+        node = manager.global_minimize_cardinality(node)
+        c2 = time.time()
+        min_card = manager.minimum_cardinality(node)
+        print("")
+        wmc = create_wmc(node, weights, args)
+        print_node(node, wmc)
+        print(f" min cardinality        : {min_card}   {c2-c1:.3f} sec")
+
+    manager_vtree = manager.vtree()
+
+    if options.post_search:
+        node.ref()
+        print("dynamic vtree (post compilation)")
+        print(f" sdd initial size       : {node.size()}")
+        c1 = time.time()
+        manager.minimize_limited()
+        c2 = time.time()
+        print(f" dynamic vtree time      : {c2-c1:.3f} sec")
+        wmc = create_wmc(node, weights, args)
+        print_node(node, wmc)
+        node.deref()
+        if options.verbose:
+            manager.print_stdout()
+
+    if options.output_sdd_filename is not None:
+        print("saving compiled sdd ...", end="")
+        node.save(options.output_sdd_filename)
+        print("done")
+
+    if options.output_sdd_dot_filename is not None:
+        print("saving compiled sdd (dot) ...", end="")
+        node.save_as_dot(options.output_sdd_dot_filename)
+        print("done")
+
+    if options.output_vtree_filename is not None:
+        print("saving vtree ...", end="")
+        manager_vtree.save(options.output_vtree_filename)
+        print("done")
+
+    if options.output_vtree_dot_filename is not None:
+        print("saving vtree (dot) ...", end="")
+        manager_vtree.save_as_dot(options.output_vtree_dot_filename)
+        print("done")
+
+    print("done")
+
+
+def create_wmc(node, weights, args):
+    if weights is None:
+        return None
+    wmc = node.wmc(log_mode=args.log_mode)
+    for i in range(len(weights)):
+        lit = (i // 2) + 1
+        if (i % 2) == 1:
+            lit = -lit
+        w = weights[i]
+        wmc.set_literal_weight(node.manager.literal(lit), w)
+    return wmc
+
+
+def read_weights(nnf_path):
+    """
+    Format: c weights PW_1 NW_1 ... PW_n NW_n
+    :param nnf_path: Path to NNF file
+    :return: list of weights
+    """
+    weight_str = None
+    with open(nnf_path, "r") as ifile:
+        for line in ifile.readlines():
+            if "c weights " in line:
+                weight_str = line[10:].strip()
+                break
+    if weight_str is None:
+        return None
+    weight_strs = weight_str.split(" ")
+    weights = [float(w) for w in weight_strs]
+    return weights
+
+
+def print_node(node, wmc=None):
+    print(f" sdd size                : {node.size()}")
+    print(f" sdd node count          : {node.count()}")
+    c1 = time.time()
+    mc = node.global_model_count()
+    c2 = time.time()
+    print(f" sdd model count         : {mc}    {c2-c1:.3f} sec")
+    if wmc is not None:
+        c1 = time.time()
+        mc = wmc.propagate()
+        c2 = time.time()
+        print(f" sdd weighted model count: {mc}    {c2-c1:.3f} sec")
+
+
+class CustomHelpFormatter(argparse.HelpFormatter):
+
+    def _format_text(self, text):
+        text = super()._format_text(text)
+        if "Copyright" in text:
+            a, b = text.split("Copyright")
+            text = a + "\n\n" + super()._format_text("Copyright" + b)
+        return text
+
+
+def create_parser():
+    def bytes_path(p):
+        return bytes(Path(p))
+
+    def bytes_str(s):
+        return s.encode()
+
+    epilog = ("Weighted Model Counting is performed if the NNF file containts a line formatted as follows: "
+              "\"c weights PW_1 NW_1 ... PW_n NW_n\"."
+              "Copyright 2017-2019, Regents of the University of California and KU Leuven")
+    parser = argparse.ArgumentParser(description='Sentential Decision Diagram, Compiler',
+                                     epilog=epilog,
+                                     formatter_class=CustomHelpFormatter)
+    input_group = parser.add_mutually_exclusive_group()
+    input_group.add_argument('-c', metavar='FILE', type=bytes_path,
+                             dest='cnf_filename', help='set input CNF file')
+    input_group.add_argument('-d', metavar='FILE', type=bytes_path,
+                             dest='dnf_filename', help='set input DNF file')
+    input_group.add_argument('-s', metavar='FILE', type=bytes_path,
+                             dest='sdd_filename', help='set input SDD file')
+    parser.add_argument('-v', metavar='FILE', type=bytes_path,
+                        dest='vtree_filename', help='set input VTREE file')
+
+    parser.add_argument('-W', metavar='FILE', type=bytes_path,
+                        dest='output_vtree_filename', help='set output VTREE file')
+    parser.add_argument('-V', metavar='FILE', type=bytes_path,
+                        dest='output_vtree_dot_filename', help='set output VTREE (dot) file')
+    parser.add_argument('-R', metavar='FILE', type=bytes_path,
+                        dest='output_sdd_filename', help='set output SDD file')
+    parser.add_argument('-S', metavar='FILE', type=bytes_path,
+                        dest='output_sdd_dot_filename', help='set output SDD (dot) file')
+
+    parser.add_argument('-m', action='store_true',
+                        dest='minimize_cardinality', help='minimize the cardinality of compiled sdd')
+
+    parser.add_argument('-t', metavar='TYPE', type=bytes_str, default='balanced',
+                        choices=[b'left', b'right', b'vertical', b'balanced', b'random'],
+                        dest='initial_vtree_type',
+                        help='set initial vtree type (left/right/vertical/balanced/random)')
+
+    parser.add_argument('-r', metavar='K', type=int, default=-1,
+                        dest='vtree_search_mode',
+                        help='if K>0: invoke vtree search every K clauses. If K=0: disable vtree search. ' +
+                             'By default (no -r option), dynamic vtree search is enabled')
+
+    parser.add_argument('-q', action='store_true',
+                        dest='post_search', help='perform post-compilation vtree search')
+
+    parser.add_argument('-p', action='store_true',
+                        dest='verbose', help='verbose output')
+
+    parser.add_argument('--log_mode', action='store_true',
+                        dest='log_mode', help='weights in log')
+
+    return parser
+
+
+def getopt(argv=None):
+    parser = create_parser()
+    args = parser.parse_args(argv)
+
+    if args.verbose:
+        logger.setLevel(logging.INFO)
+    else:
+        logger.setLevel(logging.WARNING)
+    logger.addHandler(logging.StreamHandler(sys.stdout))
+
+    options = CompilerOptions(cnf_filename=args.cnf_filename,
+                              dnf_filename=args.dnf_filename,
+                              vtree_filename=args.vtree_filename,
+                              sdd_filename=args.sdd_filename,
+                              output_vtree_filename=args.output_vtree_filename,
+                              output_vtree_dot_filename=args.output_vtree_dot_filename,
+                              output_sdd_filename=args.output_sdd_filename,
+                              output_sdd_dot_filename=args.output_sdd_dot_filename,
+                              initial_vtree_type=args.initial_vtree_type,
+                              minimize_cardinality=args.minimize_cardinality,
+                              vtree_search_mode=args.vtree_search_mode,
+                              post_search=args.post_search,
+                              verbose=args.verbose)
+    # print(str(options))
+    return options, args

pysdd/iterator.py

@@ -0,0 +1,223 @@
+# -*- coding: UTF-8 -*-
+"""
+pysdd.iterator
+~~~~~~~~~~~~~~
+
+:author: Wannes Meert, Arthur Choi
+:copyright: Copyright 2017-2019 KU Leuven and Regents of the University of California.
+:license: Apache License, Version 2.0, see LICENSE for details.
+"""
+from collections import deque
+from .sdd import SddManager, Vtree, SddNode
+from .util import BitArray
+
+MYPY = False
+if MYPY:
+    from typing import Dict, Set, Optional, List, Tuple, Callable, Union
+
+
+class SddIterator:
+    def __init__(self, sdd, smooth=True, smooth_to_root=False):
+        """Simple iterator to iterate over the SDD graph.
+
+        Supports smoothing: An arithmetic circuit AC(X) is smooth iff
+        (1) it contains at least one indicator for each variable in X, and
+        (2) for every child c of '+'-node n, we have vars(n) = vars(c).
+
+        Note, if you know that you will be performing WMC, smoothing can be implemented more efficient
+        by keeping track of the expected WMC of used and unused variables in the vtree instead of keeping
+        track of the sets of variables as is done in this iterator.
+
+        :param sdd: WmcManager
+        :param smooth: Perform smoothing while iterating over the graph
+        :param smooth_to_root: Perform smoothing wrt root instead of a given node
+        """
+        self.sdd = sdd  # type: SddManager
+        self.vtree = sdd.vtree()  # type: Vtree
+        self._wmc_cache = dict()  # type: Dict[SddNode, Union[float, int]]
+        # Map Vtree node positions to expected variables
+        self._expected_vars = None  # type: Optional[Dict[int, Set[int]]]
+        # Map Sdd nodes to missing variables
+        self._missing_vars = dict()  # type: Dict[SddNode, Set[int]]
+        self.smooth = smooth  # type: bool
+        self.smooth_to_root = smooth_to_root  # type: bool
+
+        if self.smooth:
+            self._cache_expected_vars()
+
+    def _cache_expected_vars(self):
+        self._expected_vars = dict()
+        nb_vtree_nodes = self.sdd.var_count() * 2 - 1
+        # visited = [False] * nb_vtree_nodes
+        visited = BitArray(nb_vtree_nodes)
+        queue = deque([self.vtree])
+        while len(queue) > 0:
+            node = queue.pop()  # type: Vtree
+            pos = node.position()
+            if node.is_leaf():
+                self._expected_vars[pos] = {node.var()}
+            else:
+                if visited[pos]:
+                    self._expected_vars[pos] = self._expected_vars[node.left().position()] | \
+                                               self._expected_vars[node.right().position()]
+                else:
+                    visited[pos] = True
+                    queue.append(node)
+                    queue.append(node.right())
+                    queue.append(node.left())
+
+    def depth_first_from_root(self, func):
+        # type: (SddIterator, Callable) -> List[Union[int, float]]
+        """Depth first iterator starting from the root nodes.
+
+        See `depth_first` for more details.
+        """
+        results = []
+        for node in self.vtree.get_sdd_rootnodes(self.sdd):
+            results.append(self.depth_first(node, func))
+        return results
+
+    def depth_first(self, node, func):
+        # type: (SddIterator, SddNode, Callable) -> Union[int, float]
+        """Depth first iterator
+
+        :param node: Start node
+        :param func: Function to be called for each node:
+        ``rvalue = func(node, [(prime_rvalue, sub_rvalue, prime_vars, sub_vars)],
+                        expected_prime_vars, expected_sub_vars)``
+          The given arguments are:
+          * node: Current node, if None, it should be considered a decision node
+          * prime_rvalue: Return value from prime node
+          * sub_rvalue: Return value from sub node
+          * prime_vars: Variables present in prime
+          * sub_vars: Variables present in sub
+          * expected_prime_vars: Variables that are expected in prime
+          * expected_sub_vars: Variables that are expected in sub
+          The return value can be any type, there are no assumptions.
+          For WMC this is typically float, and for MC int.
+        :return:
+        """
+        self._wmc_cache = dict()
+        if self.smooth and self._expected_vars is None:
+            self._cache_expected_vars()
+        if self.smooth and (node.is_true() or node.is_literal()):
+            wmc = func(node, None, self._expected_vars[self.vtree.position()], set())
+        else:    
+            wmc = self.depth_first_rec(node, func)
+        if self.smooth_to_root and not (node.is_true() or node.is_literal() or node.is_false()):
+            root = self.vtree.root()
+            if root != node.vtree():
+                wmc_prime = wmc
+                wmc_sub = func(self.sdd.true(), None, None, None)
+                used_prime_vars = self._expected_vars[node.vtree().position()]
+                used_sub_vars = set()
+                rvalues = [(wmc_prime, wmc_sub, used_prime_vars, used_sub_vars)]
+                expected_prime_vars = used_prime_vars
+                expected_sub_vars = self._expected_vars[root.position()] - used_prime_vars
+                wmc = func(None, rvalues, expected_prime_vars, expected_sub_vars)
+        return wmc
+
+    def depth_first_rec(self, node, func):
+        # type: (SddIterator, SddNode, Callable) -> Union[int, float]
+        if node in self._wmc_cache:
+            return self._wmc_cache[node]
+        if node.is_false():
+            result = func(node, None, None, None)
+            self._wmc_cache[node] = result
+            return result
+        if node.is_true():
+            result = func(node, None, None, None)
+            self._wmc_cache[node] = result
+            return result
+        vtree = node.vtree()
+        if node.is_decision():
+            rvalues = []
+            vtree_left = vtree.left()
+            if not self.smooth or vtree_left is None:
+                expected_prime_vars = set()
+            else:
+                expected_prime_vars = self._expected_vars[vtree_left.position()]
+            vtree_right = vtree.right()
+            if not self.smooth or vtree_right is None:
+                expected_sub_vars = set()
+            else:
+                expected_sub_vars = self._expected_vars[vtree_right.position()]
+            for prime, sub in node.elements():
+                wmc_prime = self.depth_first_rec(prime, func)
+                wmc_sub = self.depth_first_rec(sub, func)
+                if not self.smooth:
+                    used_prime_vars = None
+                    used_sub_vars = None
+                else:
+                    if prime.vtree() is None:
+                        used_prime_vars = set()
+                    else:
+                        used_prime_vars = self._expected_vars[prime.vtree().position()]
+                    if sub.vtree() is None:
+                        used_sub_vars = set()
+                    else:
+                        used_sub_vars = self._expected_vars[sub.vtree().position()]
+                rvalues.append((wmc_prime, wmc_sub, used_prime_vars, used_sub_vars))
+            rvalue = func(node, rvalues, expected_prime_vars, expected_sub_vars)
+        else:
+            rvalue = func(node, None, None, None)
+        if self._wmc_cache is not None:
+            self._wmc_cache[node] = rvalue
+        return rvalue
+
+    @staticmethod
+    def func_modelcounting(node, rvalues, expected_prime_vars, expected_sub_vars):
+        # type: (SddNode, List[Tuple[int, int, Set[int], Set[int]]], Set[int], Set[int]) -> int
+        """Method to pass on to ``depth_first`` to perform model counting.
+
+        Note that the WmcManager method to perform WMC is much more efficient, and supports weights.
+        """
+        if rvalues is None:
+            # Leaf
+            if node.is_true():
+                prime_smooth_factor = 2**len(expected_prime_vars) if expected_prime_vars is not None else 1
+                sub_smooth_factor = 2**len(expected_sub_vars) if expected_sub_vars is not None else 1
+                return prime_smooth_factor * sub_smooth_factor
+
+            elif node.is_false():
+                return 0
+
+            elif node.is_literal():
+                if expected_prime_vars is not None:
+                    nb_missing_vars = len(expected_prime_vars)
+                    if abs(node.literal) in expected_prime_vars:
+                        nb_missing_vars -= 1
+
+                    prime_smooth_factor = 2**nb_missing_vars
+                else:
+                    prime_smooth_factor = 1
+
+                if expected_sub_vars is not None:
+                    nb_missing_vars = len(expected_sub_vars)
+                    if abs(node.literal) in expected_sub_vars:
+                        nb_missing_vars -= 1
+                    sub_smooth_factor = 2**nb_missing_vars
+                else:
+                    sub_smooth_factor = 1
+
+                return prime_smooth_factor * sub_smooth_factor
+            else:
+                raise Exception("Unknown leaf type for node {}".format(node))
+        else:
+            # Decision node
+            if node is not None and not node.is_decision():
+                raise Exception("Expected a decision node for node {}".format(node))
+            rvalue = 0
+            for mc_prime, mc_sub, prime_vars, sub_vars in rvalues:
+                if prime_vars is not None:
+                    nb_missing_vars = len(expected_prime_vars) - len(prime_vars)
+                    prime_smooth_factor = 2**nb_missing_vars
+                else:
+                    prime_smooth_factor = 1
+                if sub_vars is not None:
+                    nb_missing_vars = len(expected_sub_vars) - len(sub_vars)
+                    sub_smooth_factor = 2**nb_missing_vars
+                else:
+                    sub_smooth_factor = 1
+                rvalue += mc_prime * prime_smooth_factor * mc_sub * sub_smooth_factor
+            return rvalue

pysdd/lib/libsdd-2.0/src/basic/computed.c

@@ -0,0 +1,91 @@
+/****************************************************************************************
+ * The Sentential Decision Diagram Package
+ * sdd version 2.0, January 8, 2018
+ * http://reasoning.cs.ucla.edu/sdd
+ ****************************************************************************************/
+
+#include "sdd.h"
+
+/****************************************************************************************
+ * computation cache
+ *
+ * there are two hash tables for caching computations, one for conjoin and one for disjoin
+ *
+ * there are no collision lists in these hash tables: just one entry (similar to CUDD)
+ *
+ * a cached computation may become invalid when one of its nodes is gc'd; such invalid
+ * entries are identified in a lazy manner.
+ *
+ * a node whose id is 0 must have been gc'd and is sitting on the gc list
+ * however, a node whose id is not 0 may have also been gc'd and its structure re-allocated
+ * 
+ * ids of nodes are monotonically increasing: if a node is gc'd and then re-allocated, 
+ * its new id will be larger than the old one. moreover, id=0 is reserved for nodes
+ * on the gc list. hence, if the id of a node is different than the one saved, then
+ * the node must have been gc'd 
+ ****************************************************************************************/
+
+static inline
+void delete_computed(SddComputed* computed, SddManager* manager) {
+  --manager->computed_count;
+  computed->result = NULL; //computed now deleted
+}
+
+static inline
+SddSize hash_key(SddNode* node1, SddNode* node2) {
+  return ((16777619*node1->id)^(node2->id)) % COMPUTED_CACHE_SIZE; 
+}
+
+/****************************************************************************************
+ * save
+ ****************************************************************************************/
+ 
+void cache_computation(SddNode* node1, SddNode* node2, SddNode* node, BoolOp op, SddManager* manager) {
+  assert(!GC_NODE(node) && !GC_NODE(node1) && !GC_NODE(node2));
+  assert(NON_TRIVIAL(node1) && NON_TRIVIAL(node2));
+  
+  if(node1->id > node2->id) SWAP(SddNode*,node1,node2); //for hash key
+  
+  SddSize key           = hash_key(node1,node2);
+  SddComputed* table    = op==CONJOIN? manager->conjoin_cache: manager->disjoin_cache;
+  SddComputed* computed = table+key;
+  
+  if(computed->result!=NULL) { //override current computed
+    delete_computed(computed,manager);
+  }
+  
+  ++manager->computed_count;
+  
+  computed->result  = node;
+  computed->id    = node->id; //needed to check whether result has been gc'd
+  computed->id1   = node1->id; //only id is needed for lookup
+  computed->id2   = node2->id; //only id is needed for lookup
+}
+ 
+/****************************************************************************************
+ * lookup
+ ****************************************************************************************/
+ 
+SddNode* lookup_computation(SddNode* node1, SddNode* node2, BoolOp op, SddManager* manager) {
+  assert(!GC_NODE(node1) && !GC_NODE(node2));
+  assert(NON_TRIVIAL(node1) && NON_TRIVIAL(node2));
+  
+  if(node1->id > node2->id) SWAP(SddNode*,node1,node2); //for hash key and ordered comparison
+  
+  SddSize key           = hash_key(node1,node2);
+  SddComputed* table    = op==CONJOIN? manager->conjoin_cache: manager->disjoin_cache;
+  SddComputed* computed = table+key;
+    
+  ++manager->computed_cache_lookup_count;
+  
+  if(computed->result==NULL || computed->id!=computed->result->id) return NULL; //missing or invalid computed
+  else if(computed->id1==node1->id && computed->id2==node2->id) {
+    ++manager->computed_cache_hit_count; //found it
+    return computed->result; //hit
+  }
+  else return NULL; //miss: non-matching computed for this key
+}
+ 
+/****************************************************************************************
+ * end
+ ****************************************************************************************/