def compile_tree(node, tree_state, sdd_state, label="0", st=None, path_sdd=None): if st is None: st = "" mgr = sdd_state.manager if path_sdd is None: path_sdd = sdd.sdd_manager_true(mgr) tree = tree_state.tree children = tree.successors(node) if len(children) == 0: node_label = node.attr['label'] node_label = node_label.split(':')[-1].strip().split(' ')[0] if label == node_label: # disjoin path #print st alpha = sdd.sdd_disjoin(sdd_state.alpha, path_sdd, mgr) sdd.sdd_deref(sdd_state.alpha, mgr) sdd.sdd_ref(alpha, mgr) sdd_state.alpha = alpha else: for child in children: edge = tree.get_edge(node, child) var = node.attr['label'].split(' ')[-1] val = edge.attr['label'].split(' ')[-1] child_st = st + "%s:%s " % (var, val) # extend path base_var = "_".join(var.split('_')[:-1]) + "_%d" cur_index = int(var.split('_')[-1]) low_index, high_index = 0, tree_state.constraint_info[base_var][0] beta = sdd.sdd_manager_false(mgr) if val == ">=": for i in xrange(cur_index + 1, high_index): sdd_lit = tree_state.domain[base_var % i] beta = sdd.sdd_disjoin( beta, sdd.sdd_manager_literal(sdd_lit, mgr), mgr) else: # val == "<" for i in xrange(low_index, cur_index + 1): sdd_lit = tree_state.domain[base_var % i] beta = sdd.sdd_disjoin( beta, sdd.sdd_manager_literal(sdd_lit, mgr), mgr) sdd_var = tree_state.domain[var] new_path_sdd = sdd.sdd_conjoin(path_sdd, beta, mgr) sdd_state.used_vars.add(sdd_var) child_st = st + "%s:%s " % (var, val) sdd.sdd_ref(new_path_sdd, mgr) compile_tree(child, tree_state, sdd_state, label=label, st=child_st, path_sdd=new_path_sdd) sdd.sdd_deref(new_path_sdd, mgr)
def parse_bdd(filename): var_count,node_count = pre_parse_bdd(filename) print " zdd var count:", var_count print " zdd node count:", node_count manager = start_manager(var_count,range(1,var_count+1)) root = sdd.sdd_manager_vtree(manager) nodes = [None] * (node_count+1) index,id2index = 1,{} f = open(filename) for line in f.readlines(): if line.startswith("."): break line = line.strip().split() nid = int(line[0]) dvar = int(line[1]) lo,hi = line[2],line[3] hi_lit = sdd.sdd_manager_literal( dvar,manager) lo_lit = sdd.sdd_manager_literal(-dvar,manager) if lo == 'T': lo_sdd,lo_vtree = sdd.sdd_manager_true(manager),None elif lo == 'B': lo_sdd,lo_vtree = sdd.sdd_manager_false(manager),None else: lo_id = int(lo) lo_sdd,lo_vtree = nodes[id2index[lo_id]] if hi == 'T': hi_sdd,hi_vtree = sdd.sdd_manager_true(manager),None elif hi == 'B': hi_sdd,hi_vtree = sdd.sdd_manager_false(manager),None else: hi_id = int(hi) hi_sdd,hi_vtree = nodes[id2index[hi_id]] #v1,v2 = sdd.sdd_vtree_of(hi_lit),sdd.sdd_vtree_of(hi_sdd) #vt = sdd.sdd_vtree_lca(v1,v2,root) vt = sdd.sdd_manager_vtree_of_var(dvar,manager) vt = sdd.sdd_vtree_parent(vt) vt = sdd.sdd_vtree_right(vt) if dvar < var_count: hi_sdd = zero_normalize_sdd(hi_sdd,hi_vtree,vt,manager) lo_sdd = zero_normalize_sdd(lo_sdd,lo_vtree,vt,manager) vt = sdd.sdd_vtree_parent(vt) hi_sdd = sdd.sdd_conjoin(hi_lit,hi_sdd,manager) lo_sdd = sdd.sdd_conjoin(lo_lit,lo_sdd,manager) alpha = sdd.sdd_disjoin(hi_sdd,lo_sdd,manager) nodes[index] = (alpha,vt) id2index[nid] = index index += 1 f.close() return manager,nodes[-1][0]
def _remove_dummies(alpha, var_count, pmgr): for var in xrange(1, var_count + 1): var = 3 * (var - 1) + 1 beta = sdd.sdd_manager_literal(-var, pmgr) gamma = sdd.sdd_disjoin(sdd.sdd_manager_literal(var + 1, pmgr), sdd.sdd_manager_literal(var + 2, pmgr), pmgr) beta = sdd.sdd_conjoin(beta, gamma, pmgr) alpha = sdd.sdd_conjoin(alpha, sdd.sdd_negate(beta, pmgr), pmgr) return alpha
def sdd_term(manager, variables, positive_variable): result = sdd.sdd_manager_true(manager) for variable in variables: if variable in positive_variable: result = sdd.sdd_conjoin( result, sdd.sdd_manager_literal(variable, manager), manager) else: result = sdd.sdd_conjoin( result, sdd.sdd_manager_literal(-variable, manager), manager) return result
def compatible_primes(alpha, inst, mgr, primes_mgr=None): if primes_mgr is None: beta, pmgr = primes(alpha, mgr) else: beta, pmgr = primes_mgr asdf = beta for i, val in enumerate(inst): var = i + 1 pvar = 3 * (var - 1) + 1 lit = (pvar + 1) if val == 1 else -(pvar + 1) gamma = sdd.sdd_conjoin(sdd.sdd_manager_literal(pvar, pmgr), sdd.sdd_manager_literal(lit, pmgr), pmgr) gamma = sdd.sdd_disjoin(gamma, sdd.sdd_manager_literal(-pvar, pmgr), pmgr) beta = sdd.sdd_conjoin(beta, gamma, pmgr) return beta, pmgr
def generate_exactly_two_from_tuples(sdd_manager, tuples, variables): result_constraint = sdd.sdd_manager_false(sdd_manager) for cur_tup in tuples: cur_term = sdd.sdd_manager_true(sdd_manager) for cur_var in variables: if cur_var in cur_tup: cur_term = sdd.sdd_conjoin( cur_term, sdd.sdd_manager_literal(cur_var, sdd_manager), sdd_manager) else: cur_term = sdd.sdd_conjoin( cur_term, sdd.sdd_manager_literal(-cur_var, sdd_manager), sdd_manager) result_constraint = sdd.sdd_disjoin(cur_term, result_constraint, sdd_manager) return result_constraint
def sdd_negative_term(manager, variables): result = sdd.sdd_manager_true(manager) for variable in variables: result = sdd.sdd_conjoin(result, sdd.sdd_manager_literal(-variable, manager), manager) return result
def test(): var_count = 4 vtree = sdd.sdd_vtree_new(var_count, "balanced") mgr = sdd.sdd_manager_new(vtree) # A v B alpha = sdd.sdd_disjoin(sdd.sdd_manager_literal(1, mgr), sdd.sdd_manager_literal(2, mgr), mgr) beta = sdd.sdd_conjoin(sdd.sdd_manager_literal(-3, mgr), sdd.sdd_manager_literal(-4, mgr), mgr) # A v B v ( ~C ^ ~D ) alpha = sdd.sdd_disjoin(alpha, beta, mgr) beta, pmgr = primes(alpha, mgr) _sanity_check(alpha, mgr, beta, pmgr) pvtree = sdd.sdd_manager_vtree(pmgr) import models #beta2 = sdd.sdd_global_minimize_cardinality(beta,pmgr) beta2 = beta for model in models.models(beta2, pvtree): print models.str_model(model) global cache_hits print "cache-hits:", cache_hits print "all-ones" beta, pmgr = compatible_primes(alpha, [1, 1, 1, 1], mgr) pvtree = sdd.sdd_manager_vtree(pmgr) for model in models.models(beta, pvtree): print models.str_model(model) print "all-zeros" beta, pmgr = compatible_primes(alpha, [0, 0, 0, 0], mgr) pvtree = sdd.sdd_manager_vtree(pmgr) for model in models.models(beta, pvtree): print models.str_model(model) print "blah" beta, pmgr = compatible_primes(alpha, [1, 0, 1, 0], mgr) pvtree = sdd.sdd_manager_vtree(pmgr) for model in models.models(beta, pvtree): print models.str_model(model) print "dead-nodes:", sdd.sdd_manager_dead_count(mgr) print "dead-nodes:", sdd.sdd_manager_dead_count(pmgr)
def convert_helper(node, mgr, obdd, dp, depth): if node == 'S1': return sdd.sdd_manager_true(mgr) if node == 'S0': return sdd.sdd_manager_false(mgr) if node in dp: return dp[node] var, ch0, ch1 = obdd[node][0] + 1, obdd[node][1], obdd[node][2] #print var alpha = sdd.sdd_conjoin(convert_helper(ch0, mgr, obdd, dp, depth + 1), sdd.sdd_manager_literal(-1 * var, mgr), mgr) beta = sdd.sdd_conjoin(convert_helper(ch1, mgr, obdd, dp, depth + 1), sdd.sdd_manager_literal(var, mgr), mgr) dp[node] = sdd.sdd_disjoin(alpha, beta, mgr) return dp[node]
def encode_unique_constraint(values, mgr): alpha = sdd.sdd_manager_true(mgr) # at most one for v1 in values: for v2 in values: if v1 == v2: continue beta = sdd.sdd_disjoin(sdd.sdd_manager_literal(-1 * v1, mgr), sdd.sdd_manager_literal(-1 * v2, mgr), mgr) alpha = sdd.sdd_conjoin(alpha, beta, mgr) # at least one beta = sdd.sdd_manager_false(mgr) for v in values: beta = sdd.sdd_disjoin(beta, sdd.sdd_manager_literal(v, mgr), mgr) alpha = sdd.sdd_conjoin(alpha, beta, mgr) return alpha
def _primes_one_given_term(alpha, variables, inst, cache, cache_dummy, pmgr, mgr): if len(variables) == 0: if sdd.sdd_node_is_true(alpha): return sdd.sdd_manager_true(pmgr) if sdd.sdd_node_is_false(alpha): return sdd.sdd_manager_false(pmgr) #add cases for true/false key = (len(variables), sdd.sdd_id(alpha)) if key in cache: return cache[key] var, remaining = variables[0], variables[1:] val, remaining_val = inst[0], inst[1:] beta2 = sdd.sdd_forall(var, alpha, mgr) gamma2 = _primes_one_given_term(beta2, remaining, remaining_val, cache, cache_dummy, pmgr, mgr) gamma9 = gamma2 pvar = 3 * (var - 1) + 1 kappa2 = sdd.sdd_manager_literal(-pvar, pmgr) gamma2 = sdd.sdd_conjoin(gamma2, kappa2, pmgr) if val == 0: beta0 = sdd.sdd_condition(-var, alpha, mgr) gamma0 = _primes_one_given_term(beta0, remaining, remaining_val, cache, cache_dummy, pmgr, mgr) gamma0 = sdd.sdd_conjoin(gamma0, sdd.sdd_negate(gamma9, pmgr), pmgr) kappa0 = sdd.sdd_conjoin(sdd.sdd_manager_literal(-(pvar + 1), pmgr), sdd.sdd_manager_literal((pvar + 2), pmgr), pmgr) kappa0 = sdd.sdd_conjoin(kappa0, sdd.sdd_manager_literal(pvar, pmgr), pmgr) gamma0 = sdd.sdd_conjoin(gamma0, kappa0, pmgr) #gamma0 = sdd.sdd_conjoin(gamma0,sdd.sdd_negate(gamma9,pmgr),pmgr) if val == 1: beta1 = sdd.sdd_condition(var, alpha, mgr) gamma1 = _primes_one_given_term(beta1, remaining, remaining_val, cache, cache_dummy, pmgr, mgr) gamma1 = sdd.sdd_conjoin(gamma1, sdd.sdd_negate(gamma9, pmgr), pmgr) kappa1 = sdd.sdd_conjoin(sdd.sdd_manager_literal((pvar + 1), pmgr), sdd.sdd_manager_literal(-(pvar + 2), pmgr), pmgr) kappa1 = sdd.sdd_conjoin(kappa1, sdd.sdd_manager_literal(pvar, pmgr), pmgr) gamma1 = sdd.sdd_conjoin(gamma1, kappa1, pmgr) #gamma1 = sdd.sdd_conjoin(gamma1,sdd.sdd_negate(gamma9,pmgr),pmgr) if val == 0: gamma = sdd.sdd_disjoin(gamma0, gamma2, pmgr) if val == 1: gamma = sdd.sdd_disjoin(gamma1, gamma2, pmgr) #gamma = sdd.sdd_disjoin(sdd.sdd_disjoin(gamma0, gamma1, pmgr), gamma2, pmgr) #if len(variables) > 60: # print len(variables), sdd.sdd_manager_count(mgr) cache[key] = gamma return gamma
def sdd_exactly_one_among(manager, active_variables, background_variables): if not all(x in background_variables for x in active_variables): raise Exception( "Invalid argument active variables %s, background_variables %s " % (active_variables, background_variables)) result = sdd.sdd_manager_false(manager) for positive_variable in active_variables: cur_term = sdd.sdd_manager_true(manager) for variable in background_variables: if variable != positive_variable: cur_lit = sdd.sdd_manager_literal(-variable, manager) else: cur_lit = sdd.sdd_manager_literal(variable, manager) cur_term = sdd.sdd_conjoin(cur_term, cur_lit, manager) sdd.sdd_save("t1.sdd", result) sdd.sdd_save("t2.sdd", cur_term) sdd.sdd_vtree_save("manager.vtree", sdd.sdd_manager_vtree(manager)) result = sdd.sdd_disjoin(result, cur_term, manager) return result
def test_admission(): var_count = 4 vtree = sdd.sdd_vtree_new(var_count, "balanced") mgr = sdd.sdd_manager_new(vtree) # WFEG # ( w ^ g ) alpha = sdd.sdd_conjoin(sdd.sdd_manager_literal(1, mgr), sdd.sdd_manager_literal(4, mgr), mgr) # ( w ^ f ^ e ) beta = sdd.sdd_conjoin(sdd.sdd_manager_literal(1, mgr), sdd.sdd_manager_literal(2, mgr), mgr) beta = sdd.sdd_conjoin(beta, sdd.sdd_manager_literal(3, mgr), mgr) # ( f ^ e ^ g ) gamma = sdd.sdd_conjoin(sdd.sdd_manager_literal(2, mgr), sdd.sdd_manager_literal(3, mgr), mgr) gamma = sdd.sdd_conjoin(gamma, sdd.sdd_manager_literal(4, mgr), mgr) alpha = sdd.sdd_disjoin(alpha, beta, mgr) alpha = sdd.sdd_disjoin(alpha, gamma, mgr) alpha = sdd.sdd_negate(alpha, mgr) beta, pmgr = primes(alpha, mgr) _sanity_check(alpha, mgr, beta, pmgr) vtree = sdd.sdd_manager_vtree(mgr) pvtree = sdd.sdd_manager_vtree(pmgr) import models for model in models.models(alpha, vtree): print models.str_model(model) for model in models.models(beta, pvtree): print models.str_model(model) for model in models.models(alpha, vtree): print "==", models.str_model(model) model_list = [model[var] for var in sorted(model.keys())] gamma, pmgr = compatible_primes(alpha, model_list, mgr, primes_mgr=(beta, pmgr)) pvtree = sdd.sdd_manager_vtree(pmgr) for prime_model in models.models(gamma, pvtree): print models.str_model(prime_model) term = prime_to_dict(prime_model, var_count) print " ".join([ ("*" if var not in term else "+" if term[var] == 1 else "-") for var in xrange(1, var_count + 1) ]) print "dead-nodes:", sdd.sdd_manager_dead_count(mgr) print "dead-nodes:", sdd.sdd_manager_dead_count(pmgr)
def prime_to_term(prime, mgr): """converts a prime from the IP-SDD to a term in the original manager assumes prime is an IP-model (dict from var to value)""" var_count = sdd.sdd_manager_var_count(mgr) term = sdd.sdd_manager_true(mgr) for var in xrange(1, var_count + 1): pvar = 3 * (var - 1) + 1 if prime[pvar] == 0: continue val = prime[pvar + 1] lit = var if val == 1 else -var lit = sdd.sdd_manager_literal(lit, mgr) term = sdd.sdd_conjoin(term, lit, mgr) return term
def zero_normalize_sdd(alpha,alpha_vtree,vtree,manager): if sdd.sdd_node_is_false(alpha): return alpha #if vtree == sdd.sdd_vtree_of(alpha): if vtree == alpha_vtree: return alpha if sdd.sdd_vtree_is_leaf(vtree): var = sdd.sdd_vtree_var(vtree) nlit = sdd.sdd_manager_literal(-var,manager) return nlit left,right = sdd.sdd_vtree_left(vtree),sdd.sdd_vtree_right(vtree) beta_left = zero_normalize_sdd(alpha,alpha_vtree,left,manager) beta_right = zero_normalize_sdd(alpha,alpha_vtree,right,manager) beta = sdd.sdd_conjoin(beta_left,beta_right,manager) return beta
def _primes_one(alpha, variables, cache, cache_dummy, pmgr, mgr): if len(variables) == 0: if sdd.sdd_node_is_true(alpha): return sdd.sdd_manager_true(pmgr) if sdd.sdd_node_is_false(alpha): return sdd.sdd_manager_false(pmgr) #add cases for true/false key = (len(variables), sdd.sdd_id(alpha)) if key in cache: global cache_hits cache_hits += 1 #if cache_hits % 1000 == 0: print "cache-hits-update:", cache_hits return cache[key] var, remaining = variables[0], variables[1:] beta2 = sdd.sdd_forall(var, alpha, mgr) gamma2 = _primes_one(beta2, remaining, cache, cache_dummy, pmgr, mgr) gamma9 = gamma2 pvar = 3 * (var - 1) + 1 kappa2 = sdd.sdd_manager_literal(-pvar, pmgr) gamma2 = sdd.sdd_conjoin(gamma2, kappa2, pmgr) beta0 = sdd.sdd_condition(-var, alpha, mgr) gamma0 = _primes_one(beta0, remaining, cache, cache_dummy, pmgr, mgr) gamma0 = sdd.sdd_conjoin(gamma0, sdd.sdd_negate(gamma9, pmgr), pmgr) kappa0 = sdd.sdd_conjoin(sdd.sdd_manager_literal(-(pvar + 1), pmgr), sdd.sdd_manager_literal((pvar + 2), pmgr), pmgr) kappa0 = sdd.sdd_conjoin(kappa0, sdd.sdd_manager_literal(pvar, pmgr), pmgr) gamma0 = sdd.sdd_conjoin(gamma0, kappa0, pmgr) #gamma0 = sdd.sdd_conjoin(gamma0,sdd.sdd_negate(gamma9,pmgr),pmgr) beta1 = sdd.sdd_condition(var, alpha, mgr) gamma1 = _primes_one(beta1, remaining, cache, cache_dummy, pmgr, mgr) gamma1 = sdd.sdd_conjoin(gamma1, sdd.sdd_negate(gamma9, pmgr), pmgr) kappa1 = sdd.sdd_conjoin(sdd.sdd_manager_literal((pvar + 1), pmgr), sdd.sdd_manager_literal(-(pvar + 2), pmgr), pmgr) kappa1 = sdd.sdd_conjoin(kappa1, sdd.sdd_manager_literal(pvar, pmgr), pmgr) gamma1 = sdd.sdd_conjoin(gamma1, kappa1, pmgr) #gamma1 = sdd.sdd_conjoin(gamma1,sdd.sdd_negate(gamma9,pmgr),pmgr) gamma = sdd.sdd_disjoin(gamma0, gamma1, pmgr) gamma = sdd.sdd_disjoin(gamma, gamma2, pmgr) cache[key] = gamma return gamma
def str_model(model, var_count=None): """Convert model to string.""" if var_count is None: var_count = len(model) return " ".join(str(model[var]) for var in xrange(1, var_count + 1)) if __name__ == "__main__": var_count = 10 vtree = sdd.sdd_vtree_new(var_count, "balanced") manager = sdd.sdd_manager_new(vtree) alpha = sdd.sdd_manager_false(manager) for var in xrange(1, var_count + 1): lit = sdd.sdd_manager_literal(-var, manager) alpha = sdd.sdd_disjoin(alpha, lit, manager) vt = sdd.sdd_manager_vtree(manager) model_count = 0 for model in models(alpha, vt): model_count += 1 print str_model(model, var_count=var_count) # lib_mc = sdd.sdd_model_count(alpha,manager) print "model count: %d" % model_count sdd.sdd_manager_free(manager) sdd.sdd_vtree_free(vtree)
def _encode_grid_aux(source,sink,nodes,graph,manager, base=None,cache=None,verbose=False): nodes = sorted(nodes) key = (source,tuple(nodes)) if cache and key in cache: return cache[key] if True: # INITIALIZATION FOR (S,T) PATHS if sink not in nodes: # unreachable return sdd.sdd_manager_false(manager) if len(nodes) == 1: # must be sink return sdd.sdd_manager_true(manager) if not g.reachable(source,sink,nodes): alpha = sdd.sdd_manager_false(manager) cache[key] = alpha return alpha if source == sink: # turn off all other edges alpha = sdd.sdd_manager_true(manager) sdd.sdd_ref(alpha,manager) my_nodes = list(nodes) my_nodes.remove(source) for node in my_nodes: # for all unused nodes edges = graph.incident_edges(node,nodes=nodes) sdd_vars = [ graph.edge_to_index[edge] + 1 for edge in edges ] all_false = all_false_term(sdd_vars,manager) alpha,tmp = sdd.sdd_conjoin(alpha,all_false,manager),alpha sdd.sdd_ref(alpha,manager); sdd.sdd_deref(tmp,manager) cache[key] = alpha return alpha alpha = sdd.sdd_manager_false(manager) sdd.sdd_ref(alpha,manager) else: # INITIALIZATION FOR ALL PATHS STARTING FROM S # empty graph, source should equal sink if len(nodes) == 1: return sdd.sdd_manager_true(manager) # initial case: no more paths alpha = sdd.sdd_manager_true(manager) sdd.sdd_ref(alpha,manager) my_nodes = list(nodes) my_nodes.remove(source) for node in my_nodes: # for all unused nodes edges = graph.incident_edges(node,nodes=nodes) sdd_vars = [ graph.edge_to_index[edge] + 1 for edge in edges ] all_false = all_false_term(sdd_vars,manager) alpha,tmp = sdd.sdd_conjoin(alpha,all_false,manager),alpha sdd.sdd_ref(alpha,manager); sdd.sdd_deref(tmp,manager) # after this, try to extend the paths # first, find incident edges edges = graph.incident_edges(source,nodes=nodes) sdd_vars = [ graph.edge_to_index[edge] + 1 for edge in edges ] all_false = all_false_term(sdd_vars,manager) sdd.sdd_ref(all_false,manager) # for each incident edge my_nodes = list(nodes) my_nodes.remove(source) for edge,sdd_var in zip(edges,sdd_vars): # recurse neighbor = Graph.neighbor(source,edge) gamma = _encode_grid_aux(neighbor,sink,my_nodes,graph,manager, base=base,cache=cache,verbose=verbose) if sdd.sdd_node_is_false(gamma): continue # exactly one edge on sdd_lit = sdd.sdd_manager_literal(sdd_var,manager) beta = sdd.sdd_exists(sdd_var,all_false,manager) beta = sdd.sdd_conjoin(beta,sdd_lit,manager) beta = sdd.sdd_conjoin(beta,gamma,manager) # accumulate alpha,tmp = sdd.sdd_disjoin(alpha,beta,manager),alpha sdd.sdd_ref(alpha,manager); sdd.sdd_deref(tmp,manager) sdd.sdd_deref(all_false,manager) cache[key] = alpha return alpha
def all_false_term(var_list,manager): alpha = sdd.sdd_manager_true(manager) for var in var_list: lit = sdd.sdd_manager_literal(-var,manager) alpha = sdd.sdd_conjoin(alpha,lit,manager) return alpha
def literal(self, label): self.add_variable(abs(label)) return sdd.sdd_manager_literal(label, self.__manager)
def parse_bdd(filename,var_count=None): if var_count is None: var_count,node_count = pre_parse_bdd(filename) else: max_count,node_count = pre_parse_bdd(filename) #print " zdd var count:", var_count #print " zdd node count:", node_count manager = start_manager(var_count,range(1,var_count+1)) root = sdd.sdd_manager_vtree(manager) nodes = [None] * (node_count+1) index,id2index = 1,{} f = open(filename) for line in f.readlines(): if line.startswith("."): break line = line.strip().split() nid = int(line[0]) dvar = int(line[1]) lo,hi = line[2],line[3] hi_lit = sdd.sdd_manager_literal( dvar,manager) lo_lit = sdd.sdd_manager_literal(-dvar,manager) if lo == 'T': lo_sdd,lo_vtree = sdd.sdd_manager_true(manager),None elif lo == 'B': lo_sdd,lo_vtree = sdd.sdd_manager_false(manager),None else: lo_id = int(lo) lo_sdd,lo_vtree = nodes[id2index[lo_id]] if hi == 'T': hi_sdd,hi_vtree = sdd.sdd_manager_true(manager),None elif hi == 'B': hi_sdd,hi_vtree = sdd.sdd_manager_false(manager),None else: hi_id = int(hi) hi_sdd,hi_vtree = nodes[id2index[hi_id]] #v1,v2 = sdd.sdd_vtree_of(hi_lit),sdd.sdd_vtree_of(hi_sdd) #vt = sdd.sdd_vtree_lca(v1,v2,root) vt = sdd.sdd_manager_vtree_of_var(dvar,manager) vt = sdd.sdd_vtree_parent(vt) vt = sdd.sdd_vtree_right(vt) if dvar < var_count: hi_sdd = zero_normalize_sdd(hi_sdd,hi_vtree,vt,manager) lo_sdd = zero_normalize_sdd(lo_sdd,lo_vtree,vt,manager) vt = sdd.sdd_vtree_parent(vt) hi_sdd = sdd.sdd_conjoin(hi_lit,hi_sdd,manager) lo_sdd = sdd.sdd_conjoin(lo_lit,lo_sdd,manager) alpha = sdd.sdd_disjoin(hi_sdd,lo_sdd,manager) nodes[index] = (alpha,vt) id2index[nid] = index index += 1 f.close() last_sdd,last_vtree = nodes[-1] vt = sdd.sdd_manager_vtree(manager) if vt != last_vtree: last_sdd = zero_normalize_sdd(last_sdd,last_vtree,vt,manager) return manager,last_sdd
def _sdd_unused(var, pmgr): pvar = 3 * (var - 1) + 1 kappa = sdd.sdd_conjoin(sdd.sdd_manager_literal(-(pvar + 1), pmgr), sdd.sdd_manager_literal(-(pvar + 2), pmgr), pmgr) kappa = sdd.sdd_conjoin(kappa, sdd.sdd_manager_literal(-pvar, pmgr), pmgr) return kappa
def str_model(model, var_count=None): """Convert model to string.""" if var_count is None: var_count = len(model) return " ".join(str(model[var]) for var in xrange(1, var_count + 1)) if __name__ == '__main__': var_count = 10 vtree = sdd.sdd_vtree_new(var_count, "balanced") manager = sdd.sdd_manager_new(vtree) alpha = sdd.sdd_manager_false(manager) for var in xrange(1, var_count + 1): lit = sdd.sdd_manager_literal(-var, manager) alpha = sdd.sdd_disjoin(alpha, lit, manager) vt = sdd.sdd_manager_vtree(manager) model_count = 0 for model in models(alpha, vt): model_count += 1 print str_model(model, var_count=var_count) #lib_mc = sdd.sdd_model_count(alpha,manager) print "model count: %d" % model_count sdd.sdd_manager_free(manager) sdd.sdd_vtree_free(vtree)
def test_andy(): var_count = 3 vtree = sdd.sdd_vtree_new(var_count, "balanced") mgr = sdd.sdd_manager_new(vtree) # 100, 101, 111, 001, 011 alpha = sdd.sdd_manager_false(mgr) beta = sdd.sdd_conjoin(sdd.sdd_manager_literal(1, mgr), sdd.sdd_manager_literal(-2, mgr), mgr) beta = sdd.sdd_conjoin(sdd.sdd_manager_literal(-3, mgr), beta, mgr) alpha = sdd.sdd_disjoin(alpha, beta, mgr) beta = sdd.sdd_conjoin(sdd.sdd_manager_literal(1, mgr), sdd.sdd_manager_literal(-2, mgr), mgr) beta = sdd.sdd_conjoin(sdd.sdd_manager_literal(3, mgr), beta, mgr) alpha = sdd.sdd_disjoin(alpha, beta, mgr) beta = sdd.sdd_conjoin(sdd.sdd_manager_literal(1, mgr), sdd.sdd_manager_literal(2, mgr), mgr) beta = sdd.sdd_conjoin(sdd.sdd_manager_literal(3, mgr), beta, mgr) alpha = sdd.sdd_disjoin(alpha, beta, mgr) beta = sdd.sdd_conjoin(sdd.sdd_manager_literal(-1, mgr), sdd.sdd_manager_literal(-2, mgr), mgr) beta = sdd.sdd_conjoin(sdd.sdd_manager_literal(3, mgr), beta, mgr) alpha = sdd.sdd_disjoin(alpha, beta, mgr) beta = sdd.sdd_conjoin(sdd.sdd_manager_literal(-1, mgr), sdd.sdd_manager_literal(2, mgr), mgr) beta = sdd.sdd_conjoin(sdd.sdd_manager_literal(3, mgr), beta, mgr) alpha = sdd.sdd_disjoin(alpha, beta, mgr) beta, pmgr = primes(alpha, mgr) _sanity_check(alpha, mgr, beta, pmgr) vtree = sdd.sdd_manager_vtree(mgr) pvtree = sdd.sdd_manager_vtree(pmgr) import models for model in models.models(alpha, vtree): print models.str_model(model) for model in models.models(beta, pvtree): print models.str_model(model) print "dead-nodes:", sdd.sdd_manager_dead_count(mgr) print "dead-nodes:", sdd.sdd_manager_dead_count(pmgr)