def sparse_random_system(ring, number_of_polynomials, variables_per_polynomial, degree, random_seed=None): """ generates a system, which is sparse in the sense, that each polynomial contains only a small subset of variables. In each variable that occurrs in a polynomial it is dense in the terms up to the given degree (every term occurs with probability 1/2). The system will be satisfiable by at least one solution. >>> from polybori import * >>> r=Ring(10) >>> s=sparse_random_system(r, number_of_polynomials = 20, variables_per_polynomial = 3, degree=2, random_seed=123) >>> [p.deg() for p in s] [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2] >>> sorted(groebner_basis(s), reverse=True) [x(0), x(1), x(2), x(3), x(4) + 1, x(5), x(6) + 1, x(7), x(8) + 1, x(9)] """ if random_seed is not None: set_random_seed(random_seed) random_generator = Random(random_seed) solutions=[] variables = [ring.variable(i) for i in xrange(ring.n_variables())] for v in variables: solutions.append(v+random_generator.randint(0,1)) solutions=ll_encode(solutions) res = [] while len(res)<number_of_polynomials: variables_as_monomial=Monomial( random_generator.sample( variables, variables_per_polynomial) ) p=Polynomial(random_set(variables_as_monomial, 2**(variables_per_polynomial-1))) p=sum([p.graded_part(i) for i in xrange(degree+1)]) if p.deg()==degree: res.append(p) res=[p+ll_red_nf_redsb(p, solutions) for p in res]# evaluate it to guarantee a solution return res
def add_bits_old(bits): """Adds n bits >>> from polybori import * >>> r=Ring(10) >>> add_bits_old([r.variable(i) for i in xrange(3)]) [x(0) + x(1) + x(2), x(0)*x(1) + x(0)*x(2) + x(1)*x(2)] >>> add_bits_old([r.variable(i) for i in xrange(4)]) [x(0) + x(1) + x(2) + x(3), x(0)*x(1) + x(0)*x(2) + x(0)*x(3) + x(1)*x(2) + x(1)*x(3) + x(2)*x(3)] """ bits = list(bits) n = len(bits) deg_d_monomials = [ Polynomial(all_monomials_of_degree_d(i, bits)) for i in xrange(n + 1) ] full = power_set(bits) bits_expr = [] # [sum(bits)] step = 0 while n > 2**step: to_one = sum( [deg_d_monomials[i] for i in xrange(n + 1) if i & 2**step]) to_one = Polynomial(to_one) fun = PartialFunction(ones=to_one, zeros=full.diff(to_one)) poly = fun.interpolate_smallest_lex() bits_expr.append(poly) step = step + 1 return bits_expr
def all_monomials_of_degree_d(d, variables): variables = Monomial(variables) variables = list(variables.variables()) if not variables: assert d == 0 return BooleConstant(1) ring = variables[0].ring() if d > len(variables): return Polynomial(0, ring) if d < 0: return Polynomial(1, ring) deg_variables = variables[-d:] #this ensures sorting by indices res = Monomial(deg_variables) for i in xrange(1, len(variables) - d + 1): deg_variables = variables[-d - i:-i] res = Polynomial(res) nav = res.navigation() navs = [] while not nav.constant(): navs.append(BooleSet(nav, ring)) nav = nav.then_branch() acc = Polynomial(1, ring) for (nav, v) in reversed(zip(navs, deg_variables)): acc = if_then_else(v, acc, nav) res = acc return res.set()
def proofll(ifthen, reductors, redsb=True, prot=True): if prot and (not ifthen.supposedToBeValid): print "THIS THEOREM IS NOT SUPPOSED TO BE VALID" ip_pre = ifthen.ifpart ip = [] for p in ip_pre: p = Polynomial(p) if p.is_zero(): continue li = list(p.lead().variables()) if len(li) == 1 and (not (li[0] in list(Polynomial(reductors).lead(). variables()))): assert not Polynomial(reductors).is_zero() lead_index = li[0] if redsb: p = ll_red_nf_redsb(p, reductors) reductors = ll_red_nf_redsb(Polynomial(reductors), BooleSet(p. set())) p_nav = p.navigation() reductors = recursively_insert(p_nav.else_branch(), p_nav.value(), reductors) else: ip.append(p) it = ifthen.thenpart if prot: print "proofing:", ifthen ip = logicaland(ip) for c in it: if prot: print "proofing part:", c c = logicalor([BooleConstant(1) + ip, c]) if c.is_zero(): if prot: print "TRUE (trivial)" return True else: c_orig = c if redsb: c = ll_red_nf_redsb(c, reductors) else: c = ll_red_nf_noredsb(c, reductors) if c.is_zero(): if prot: print "TRUE" return True else: if prot: print "FAILED" print "can construct COUNTER EXAMPLE with:", find_one(c) return False
def add_simple_poly(p,i): p=Polynomial(p) if p.is_zero(): return res_p=Polynomial(res.get(i, Polynomial(0, p.ring()))) res[i]=res_p+p if res[i].is_zero(): del res[i] inter=BooleSet(res_p).intersect(BooleSet(p)) add_simple_poly(inter, i+1) return
def proofll(ifthen, reductors, redsb=True, prot=True): if prot and (not ifthen.supposedToBeValid): print "THIS THEOREM IS NOT SUPPOSED TO BE VALID" ip_pre = ifthen.ifpart ip = [] for p in ip_pre: p = Polynomial(p) if p.is_zero(): continue li = list(p.lead().variables()) if len(li) == 1 and (not (li[0] in list( Polynomial(reductors).lead().variables()))): assert not Polynomial(reductors).is_zero() lead_index = li[0] if redsb: p = ll_red_nf_redsb(p, reductors) reductors = ll_red_nf_redsb(Polynomial(reductors), BooleSet(p.set())) p_nav = p.navigation() reductors = recursively_insert(p_nav.else_branch(), p_nav.value(), reductors) else: ip.append(p) it = ifthen.thenpart if prot: print "proofing:", ifthen ip = logicaland(ip) for c in it: if prot: print "proofing part:", c c = logicalor([BooleConstant(1) + ip, c]) if c.is_zero(): if prot: print "TRUE (trivial)" return True else: c_orig = c if redsb: c = ll_red_nf_redsb(c, reductors) else: c = ll_red_nf_noredsb(c, reductors) if c.is_zero(): if prot: print "TRUE" return True else: if prot: print "FAILED" print "can construct COUNTER EXAMPLE with:", find_one(c) return False
def interred(l, completely=False): """computes a new generating system (g1, ...,gn), spanning the same ideal modulo field equations. The system is interreduced: For i!=j: gi.lead() does not divide any leading term of gj. If completely is set to True, then also terms in the tail are not reducible by other polynomials. """ l = [Polynomial(p) for p in l if not p == 0] if not l: return [] ring = l[0].ring() l_old = None l = tuple(l) while l_old != l: l_old = l l = sorted(l, key=Polynomial.lead) g = ReductionStrategy(ring) if completely: g.opt_red_tail = True for p in l: p = g.nf(p) if not p.is_zero(): g.add_generator(p) l = tuple([e.p for e in g]) return list(l)
def power_set(variables): if not variables: return BooleConstant(1) variables = sorted(set(variables), reverse=True, key=top_index) res = Polynomial(1, variables[0].ring()).set() for v in variables: res = if_then_else(v, res, res) return res
def all_monomials_of_degree_d_old(d, variables): if d == 0: return BooleConstant(1) if not variables: return [] variables = sorted(set(variables), reverse=True, key=top_index) m = variables[-1] for v in variables[:-1]: m = v + m m = m.set() i = 0 res = Polynomial(variables[0].ring().one()).set() while (i < d): i = i + 1 res = res.cartesian_product(m).diff(res) return res
def all_monomials_of_degree_d_old(d,variables): if d==0: return BooleConstant(1) if not variables: return [] variables=sorted(set(variables),reverse=True,key=top_index) m=variables[-1] for v in variables[:-1]: m=v+m m=m.set() i=0 res=Polynomial(variables[0].ring().one()).set() while(i<d): i=i+1 res=res.cartesian_product(m).diff(res) return res
def gen_strat(polys): polys = [Polynomial(p) for p in polys] polys = [p for p in polys if not p.is_zero()] assert len(set([p.lead() for p in polys])) == len(polys) assert polys strat = GroebnerStrategy(polys[0].ring()) for p in polys: print "Adding" strat.add_generator(p) print "finished" return strat
def gen_random_poly(ring, l,deg,vars_set,seed=123): myrange=vars_set r=Random(seed) def helper(samples): if samples==0: return Polynomial(ring.zero()) if samples==1: d=r.randint(0,deg) variables=r.sample(myrange,d) m=Monomial(ring) for v in sorted(set(variables),reverse=True): m=m*Variable(v, ring) return Polynomial(m) assert samples>=2 return helper(samples/2)+helper(samples-samples/2) p=Polynomial(ring.zero()) while(len(p)<l): p=Polynomial(p.set().union(helper(l-len(p)).set())) return p
def vars_real_divisors(monomial, monomial_set): """ returns all elements of of monomial_set, which result multiplied by a variable in monomial. >>> from polybori.PyPolyBoRi import OrderCode >>> dp_asc = OrderCode.dp_asc >>> from polybori.PyPolyBoRi import Ring >>> r=Ring(1000) >>> x = r.variable >>> b=BooleSet([x(1)*x(2),x(2)]) >>> vars_real_divisors(x(1)*x(2)*x(3),b) {{x(1),x(2)}} """ return BooleSet(Polynomial(monomial_set.divisors_of(monomial)). \ graded_part(monomial.deg() - 1))
def dense_system(I): I = (Polynomial(p) for p in I) I = (p for p in I if not p.is_zero()) for p in I: d = p.deg() if p.deg() == 1: continue else: try: if len(p) > 2**d + 5: return True except OverflowError: return True return False
def main(): r = Ring(1000) x = Variable = VariableFactory(r) from os import system from polybori.specialsets import all_monomials_of_degree_d, power_set full_set = list(power_set([Variable(i) for i in xrange(15)])) from random import Random generator = Random(123) random_set = sum(generator.sample(full_set, 30)) full_polynomial = list( all_monomials_of_degree_d(3, [Variable(i) for i in xrange(30)])) random_poly = sum(generator.sample(full_polynomial, 30)) polynomials = [ x(1) * x(2) + x(3), (x(1) + 1) * (x(2) + x(3)), (x(1) + 1) * (x(2) + 1) * (x(3) + 1), x(1) * x(2) + x(2) * x(3) + x(1) * x(3) + x(1), x(0) + x(1) + x(2) + x(3) + x(4) + x(5), all_monomials_of_degree_d(3, [x(i) for i in xrange(10)]), power_set([x(i) for i in xrange(10)]), random_poly, random_set, Polynomial(all_monomials_of_degree_d(3, [x(i) for i in xrange(10)])) + Polynomial(power_set([x(i) for i in xrange(10)])), Polynomial(power_set([x(i) for i in xrange(10)])) + 1 ] for colored in [True, False]: if colored: colored_suffix = "_colored" else: colored_suffix = "" for format in ["png", "svg"]: for (i, p) in enumerate(polynomials): #dot_file=str(i) +colored_suffix+".dot" #f=open(dot_file, "w") #f.write(dot) #f.close() out_file = str(i) + colored_suffix + "." + format plot(p, out_file, colored=colored, format=format)
def __coerce__(self, other): #TODO handle long if isinstance(other, int) and other >= 0: i = 0 res = [] while 2**i <= other: and_ = 2**i & other if and_: res.append(i) return (self, IntegerPolynomial( dict([(i, BooleConstant(1)) for i in res]))) if not isinstance(other, IntegerPolynomial): other = Polynomial(other) return (self, IntegerPolynomial(dict([(0, other)])))
def gauss_on_linear(I): I = (Polynomial(p) for p in I) linear = [] non_linear = [] for p in I: if p.is_zero(): continue if p.deg() <= 1: linear.append(p) else: non_linear.append(p) if len(linear) == 0: return non_linear linear = list(gauss_on_polys(linear)) return linear + non_linear
def add_simple_poly(p, i): p = Polynomial(p) if p.is_zero(): return res_p = Polynomial(res.get(i, Polynomial(0, p.ring()))) res[i] = res_p + p if res[i].is_zero(): del res[i] inter = BooleSet(res_p).intersect(BooleSet(p)) add_simple_poly(inter, i + 1) return
def register(self, start, context): super(AdderBlock, self).register(start, context) a = context[self.input1] b = context[self.input2] self.s = shift(context[self.sums], self.start_index) self.c = shift(context[self.carries], self.start_index) a = shift(a, self.start_index) b = shift(b, self.start_index) carries = [Polynomial(a(0).ring().zero())] for i in xrange(self.adder_bits): #print i, ":" c = 1 + (1 + a(i) * b(i)) * (1 + carries[-1] * a(i)) * ( 1 + carries[-1] * b(i)) carries.append(c) self.add_results = [ a(i) + b(i) + carries[i] for i in xrange(self.adder_bits) ] self.carries_polys = carries[1:]
def from_fast_pickable(l, r): """from_fast_pickable(l, ring) undoes the operation to_fast_pickable. The first argument is an object created by to_fast_pickable. For the specified format, see the documentation of to_fast_pickable. The second argument is ring, in which this polynomial should be created. INPUT: see OUTPUT of to_fast_pickable OUTPUT: a list of Boolean polynomials EXAMPLES: >>> from polybori.PyPolyBoRi import Ring >>> r=Ring(1000) >>> x = r.variable >>> from_fast_pickable([[1], []], r) [1] >>> from_fast_pickable([[0], []], r) [0] >>> from_fast_pickable([[2], [(0, 1, 0)]], r) [x(0)] >>> from_fast_pickable([[2], [(1, 1, 0)]], r) [x(1)] >>> from_fast_pickable([[2], [(0, 1, 1)]], r) [x(0) + 1] >>> from_fast_pickable([[2], [(0, 3, 0), (1, 1, 0)]], r) [x(0)*x(1)] >>> from_fast_pickable([[2], [(0, 3, 3), (1, 1, 0)]], r) [x(0)*x(1) + x(1)] >>> from_fast_pickable([[2], [(0, 3, 4), (1, 1, 0), (2, 1, 0)]], r) [x(0)*x(1) + x(2)] >>> from_fast_pickable([[2, 0, 1, 4], [(0, 3, 0), (1, 1, 0), (3, 1, 0)]], r) [x(0)*x(1), 0, 1, x(3)] """ i2poly = {0: r.zero(), 1: r.one()} (indices, terms) = l for i in reversed(xrange(len(terms))): (v, t, e) = terms[i] t = i2poly[t] e = i2poly[e] terms[i] = if_then_else(v, t, e) i2poly[i + 2] = terms[i] return [Polynomial(i2poly[i]) for i in indices]
def add_bits(bits): """Adds n bit variables, by Lucas theorem >>> from polybori import * >>> r=Ring(10) >>> add_bits([r.variable(i) for i in xrange(3)]) [x(0) + x(1) + x(2), x(0)*x(1) + x(0)*x(2) + x(1)*x(2)] >>> add_bits([r.variable(i) for i in xrange(4)]) [x(0) + x(1) + x(2) + x(3), x(0)*x(1) + x(0)*x(2) + x(0)*x(3) + x(1)*x(2) + x(1)*x(3) + x(2)*x(3), x(0)*x(1)*x(2)*x(3)] >>> add_bits([r.variable(0)]) [x(0)] """ bits = list(bits) if len(bits) < 2: return bits n = len(bits) bits_expr = [] # [sum(bits)] step = 0 while n >= 2**step: bits_expr.append(Polynomial(all_monomials_of_degree_d(2**step, bits))) step = step + 1 return bits_expr
print list(all_monomials_of_degree_d(3, [Variable(i) for i in range(4)])) print list(all_monomials_of_degree_d(4, [Variable(i) for i in range(4)])) print list(all_monomials_of_degree_d(0, [])) print list(all_monomials_of_degree_d(1, [])) print list(power_set([Variable(i) for i in range(2)])) print list(power_set([Variable(i) for i in range(4)])) print list(power_set([])) #every monomial in the first 8 var, which is at most linear in the first 5 print list( mod_mon_set( power_set([Variable(i) for i in range(8)]), all_monomials_of_degree_d(2, [Variable(i) for i in range(5)]))) #specialized normal form computation print Polynomial( mod_mon_set( (x(1) * x(2) + x(1) + 1).set(), all_monomials_of_degree_d(2, [Variable(i) for i in range(1000)]))) print list( mod_mon_set( power_set([Variable(i) for i in range(50)]), all_monomials_of_degree_d(2, [Variable(i) for i in range(1000)]))) def monomial_from_indices(ring, indices): l = sorted(indices, reverse=True) res = Monomial(ring) for i in l: res = res * ring.variable(i) return res
def plot(p, filename, colored=True, format="png", highlight_monomial=None, fontsize=14, template_engine='jinja', landscape=False): """plots ZDD structure to <filename> in format <format> EXAMPLES: >>> r=Ring(1000) >>> x = r.variable >>> plot(x(1)+x(0),"/dev/null", colored=True) >>> plot(x(1)+x(0),"/dev/null", colored=False) """ THICK_PEN = 5 highlight_path = dict() if highlight_monomial: highlight_path = monomial_path_in_zdd(highlight_monomial, p) def display_monomial(m): return unicode(m).replace("*", u"⋅") def penwidth_else(n): if n in highlight_path and highlight_path[n] == ELSE: return THICK_PEN return 1 def penwidth_then(n): if n in highlight_path and highlight_path[n] == THEN: return THICK_PEN return 1 if not colored: color_then = "black" color_else = "black" else: color_then = "red" color_else = "blue" def find_navs(nav): if not nav in nodes: nodes.add(nav) if not nav.constant(): find_navs(nav.then_branch()) find_navs(nav.else_branch()) p = Polynomial(p) nodes = set() nav = p.navigation() find_navs(nav) non_constant_nodes = [n for n in nodes if not n.constant()] node_to_int = dict([(n, i) for (i, n) in enumerate(nodes)]) r = p.ring() def identifier(n): return "n" + str(node_to_int[n]) def label(n): if n.constant(): if n.terminal_one(): return "1" else: return "0" else: return str(r.variable(n.value())) def shape(n): if n.constant(): return "box" else: return "ellipse" renderers = dict(genshi=render_genshi, jinja=render_jinja) dot_input = renderers[template_engine](locals()) if isinstance(dot_input, unicode): dot_input = dot_input.encode('utf-8') process = Popen(["dot", "-T" + format, "-o", filename], stdin=PIPE, stdout=PIPE) process.stdin.write(dot_input) process.stdin.close() process.wait()
def zero_blocks(self, f): """divides the zero set of f into blocks >>> from polybori import * >>> r = declare_ring(["x", "y", "z"], dict()) >>> e = CNFEncoder(r) >>> e.zero_blocks(r.variable(0)*r.variable(1)*r.variable(2)) [{y: 0}, {z: 0}, {x: 0}] """ f=Polynomial(f) variables = f.vars_as_monomial() space = variables.divisors() variables = list(variables.variables()) zeros = f.zeros_in(space) rest = zeros res = list() def choose_old(s): return iter(rest).next()# somewhat #inefficient compared to polynomials lex_lead def choose(s): indices = [] assert not s.empty() nav = s.navigation() while not nav.constant(): e = nav.else_branch() t = nav.then_branch() if e.constant() and not e.terminal_one(): indices.append(nav.value()) nav = t else: if self.random_generator.randint(0,1): indices.append(nav.value()) nav = t else: nav = e assert nav.terminal_one() res = self.one_set for i in reversed(indices): res = ite(i, res, self.empty_set) return iter(res).next() while not rest.empty(): l = choose(rest) l_variables = set(l.variables()) def get_val(var): if var in l_variables: return 1 return 0 block_dict = dict([(v, get_val(v)) for v in variables]) l = l.set() self.random_generator.shuffle(variables) for v in variables: candidate = l.change(v.index()) if candidate.diff(zeros).empty(): l = l.union(candidate) del block_dict[v] rest = rest.diff(l) res.append(block_dict) return res
def preprocess(I, prot=True): def min_gb(I): strat = symmGB_F2_C(I, opt_lazy=False, opt_exchange=False, prot=prot, selection_size=10000, opt_red_tail=True) return list(strat.minimalize_and_tail_reduce()) I = [Polynomial(p) for p in I] lin = [p for p in I if p.deg() == 1] # lin_strat=symmGB_F2_C(lin, opt_lazy=False,opt_exchange=False,prot=prot,sele # ction_size=10000,opt_red_tail=True) lin = min_gb(lin) # list(lin_strat.minimalize_and_tail_reduce()) for m in sorted([p.lead() for p in lin]): print m lin_ll = ll_encode(lin) square = [p.lead() for p in I if p.deg() == 2 and len(p) == 1] assert (len(lin) + len(square) == len(I)) res = list(lin) counter = OccCounter() def unique_index(s): for idx in s: if counter[idx] == 1: return idx never_come_here = False assert never_come_here for m in square: for idx in m: counter.increase(idx) systems = dict(((idx, []) for idx in counter.uniques())) for m in square: u_index = unique_index(m) systems[u_index].append(ll_red_nf(m / Variable(u_index), lin_ll)) rewritings = dict() u_var = Variable(u) u_im = ll_red_nf(u_var, lin_ll) if not u_im.isConstant(): if u_im != u_var: r = u_im.navigation().value() else: pass for u in counter.uniques(): #print u u_var = Variable(u) u_im = ll_red_nf(u_var, lin_ll) if not u_im.isConstant(): if u_im != u_var: r = u_im.navigation().value() else: pass for u in systems.keys(): u_var = Variable(u) u_im = ll_red_nf(u_var, lin_ll) res.extend([u_im * p for p in min_gb(systems[u])]) #print [u_im*p for p in min_gb(systems[u])] print "lin:", len(lin), "res:", len(res), "square:", len(square) res = [p for p in (Polynomial(p) for p in res) if not p.is_zero()] return res
def zero_blocks(self, f): """divides the zero set of f into blocks >>> from polybori import * >>> r = declare_ring(["x", "y", "z"], dict()) >>> e = CNFEncoder(r) >>> e.zero_blocks(r.variable(0)*r.variable(1)*r.variable(2)) [{y: 0}, {z: 0}, {x: 0}] """ f = Polynomial(f) variables = f.vars_as_monomial() space = variables.divisors() variables = list(variables.variables()) zeros = f.zeros_in(space) rest = zeros res = list() def choose_old(s): return iter(rest).next() # somewhat #inefficient compared to polynomials lex_lead def choose(s): indices = [] assert not s.empty() nav = s.navigation() while not nav.constant(): e = nav.else_branch() t = nav.then_branch() if e.constant() and not e.terminal_one(): indices.append(nav.value()) nav = t else: if self.random_generator.randint(0, 1): indices.append(nav.value()) nav = t else: nav = e assert nav.terminal_one() res = self.one_set for i in reversed(indices): res = ite(i, res, self.empty_set) return iter(res).next() while not rest.empty(): l = choose(rest) l_variables = set(l.variables()) def get_val(var): if var in l_variables: return 1 return 0 block_dict = dict([(v, get_val(v)) for v in variables]) l = l.set() self.random_generator.shuffle(variables) for v in variables: candidate = l.change(v.index()) if candidate.diff(zeros).empty(): l = l.union(candidate) del block_dict[v] rest = rest.diff(l) res.append(block_dict) return res
def __init__(self, boolean_polys): super(IntegerPolynomial, self).__init__() if not isinstance(boolean_polys, dict): boolean_polys = dict([(0, Polynomial(boolean_polys))]) self.boolean_polys = boolean_polys
def pickle_bset(self): return (BooleSet, (Polynomial(self), ))
def plot(p, filename, colored=True, format="png", highlight_monomial=None, fontsize=14, template_engine='jinja', landscape=False ): """plots ZDD structure to <filename> in format <format> EXAMPLES: >>> r=Ring(1000) >>> x = r.variable >>> plot(x(1)+x(0),"/dev/null", colored=True) >>> plot(x(1)+x(0),"/dev/null", colored=False) """ THICK_PEN = 5 highlight_path = dict() if highlight_monomial: highlight_path = monomial_path_in_zdd(highlight_monomial, p) def display_monomial(m): return unicode(m).replace("*", u"⋅") def penwidth_else(n): if n in highlight_path and highlight_path[n] == ELSE: return THICK_PEN return 1 def penwidth_then(n): if n in highlight_path and highlight_path[n] == THEN: return THICK_PEN return 1 if not colored: color_then = "black" color_else = "black" else: color_then = "red" color_else = "blue" def find_navs(nav): if not nav in nodes: nodes.add(nav) if not nav.constant(): find_navs(nav.then_branch()) find_navs(nav.else_branch()) p = Polynomial(p) nodes = set() nav = p.navigation() find_navs(nav) non_constant_nodes = [n for n in nodes if not n.constant()] node_to_int = dict([(n, i) for (i, n) in enumerate(nodes)]) r = p.ring() def identifier(n): return "n" + str(node_to_int[n]) def label(n): if n.constant(): if n.terminal_one(): return "1" else: return "0" else: return str(r.variable(n.value())) def shape(n): if n.constant(): return "box" else: return "ellipse" renderers = dict(genshi=render_genshi, jinja=render_jinja) dot_input = renderers[template_engine](locals()) if isinstance(dot_input, unicode): dot_input = dot_input.encode('utf-8') process = Popen(["dot", "-T" + format, "-o", filename], stdin=PIPE, stdout=PIPE) process.stdin.write(dot_input) process.stdin.close() process.wait()
def __init__(self, ifpart, thenpart, supposed_to_be_valid=True): self.ifpart = [Polynomial(p) for p in ifpart] self.thenpart = [Polynomial(p) for p in thenpart] self.supposedToBeValid = supposed_to_be_valid