Replace "from brial" with "from sage.rings.polynomial.pbori.brial"

Author: kiwifb

src/sage/rings/polynomial/multi_polynomial_sequence.py

@@ -1249,8 +1249,8 @@ def eliminate_linear_variables(self, maxlength=Infinity, skip=None, return_reduc
             This is called "massaging" in [BCJ2007]_.
         """
         from sage.rings.polynomial.pbori.pbori import BooleanPolynomialRing
-        from brial import gauss_on_polys
-        from brial.ll import eliminate,ll_encode,ll_red_nf_redsb
+        from sage.rings.polynomial.pbori.brial import gauss_on_polys
+        from sage.rings.polynomial.pbori.brial.ll import eliminate,ll_encode,ll_red_nf_redsb
 
         R = self.ring()
 
@@ -1534,7 +1534,7 @@ def reduced(self):
         R = self.ring()
 
         if isinstance(R, BooleanPolynomialRing):
-            from brial.interred import interred as inter_red
+            from sage.rings.polynomial.pbori.brial.interred import interred as inter_red
             l = [p for p in self if not p==0]
             l = sorted(inter_red(l, completely=True), reverse=True)
             return PolynomialSequence(l, R, immutable=True)

src/sage/rings/polynomial/pbori/PyPolyBoRi.py

@@ -8,7 +8,7 @@
 
             Examples:
 
-            >>> from brial.frontend import *
+            >>> from sage.rings.polynomial.pbori.brial.frontend import *
             >>> r=declare_ring(["x0","x1","x2","y0","y1","y2"], globals())
             >>> x0>x1
             True

src/sage/rings/polynomial/pbori/addition.py

@@ -6,7 +6,7 @@
 
 def add_bits_old(bits):
     """Adds n bits
-    >>> from brial import *
+    >>> from sage.rings.polynomial.pbori.brial 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)]
@@ -33,7 +33,7 @@ def add_bits_old(bits):
 
 def add_bits(bits):
     """Adds n bit variables, by Lucas theorem
-    >>> from brial import *
+    >>> from sage.rings.polynomial.pbori.brial 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)]
@@ -59,7 +59,7 @@ def add_bits(bits):
 def add_bit_expressions(bit_expressions):
     """Adds n bits, which can be arbitrary expressions, the first n variables of the ring    are reversed for usage in this function.
 
-    >>> from brial import *
+    >>> from sage.rings.polynomial.pbori.brial import *
     >>> r=Ring(20)
     >>> add_bit_expressions([r.variable(i) for i in xrange(10,13)])
     [x(10) + x(11) + x(12), x(10)*x(11) + x(10)*x(12) + x(11)*x(12)]
@@ -85,7 +85,7 @@ def add_bit_expressions(bit_expressions):
 
 def add_words(words):
     """def adds n words, this words are supposed to consists of list of their bits.
-    >>> from brial import *
+    >>> from sage.rings.polynomial.pbori.brial import *
     >>> r=Ring(1000)
     >>> add_words([[r.variable(100+i*3+j) for i in xrange(2)] for j in xrange(3)])
     [x(100) + x(101) + x(102), x(100)*x(101) + x(100)*x(102) + x(101)*x(102) + x(103) + x(104) + x(105), x(100)*x(101)*x(103) + x(100)*x(101)*x(104) + x(100)*x(101)*x(105) + x(100)*x(102)*x(103) + x(100)*x(102)*x(104) + x(100)*x(102)*x(105) + x(101)*x(102)*x(103) + x(101)*x(102)*x(104) + x(101)*x(102)*x(105) + x(103)*x(104) + x(103)*x(105) + x(104)*x(105), x(100)*x(101)*x(103)*x(104)*x(105) + x(100)*x(102)*x(103)*x(104)*x(105) + x(101)*x(102)*x(103)*x(104)*x(105)]
@@ -112,7 +112,7 @@ def add_words(words):
 
 def multiply_by_addition(word_a, word_b):
     """Multiply two words
-    >>> from brial import Ring
+    >>> from sage.rings.polynomial.pbori.brial import Ring
     >>> r=Ring(1000)
     >>> x = r.variable
     >>> n=7

src/sage/rings/polynomial/pbori/cnf.py

@@ -14,7 +14,7 @@ def __init__(self, r, random_seed=16):
 
     def zero_blocks(self, f):
         """divides the zero set of f into blocks
-        >>> from brial import *
+        >>> from sage.rings.polynomial.pbori.brial import *
         >>> r = declare_ring(["x", "y", "z"], dict())
         >>> e = CNFEncoder(r)
         >>> e.zero_blocks(r.variable(0)*r.variable(1)*r.variable(2))
@@ -78,7 +78,7 @@ def get_val(var):
 
     def clauses(self, f):
         """
-        >>> from brial import *
+        >>> from sage.rings.polynomial.pbori.brial import *
         >>> r = declare_ring(["x", "y", "z"], dict())
         >>> e = CNFEncoder(r)
         >>> e.clauses(r.variable(0)*r.variable(1)*r.variable(2)) # doctest:+ELLIPSIS
@@ -102,7 +102,7 @@ def clauses(self, f):
 
     def polynomial_clauses(self, f):
         """
-        >>> from brial import *
+        >>> from sage.rings.polynomial.pbori.brial import *
         >>> r = declare_ring(["x", "y", "z"], dict())
         >>> e = CNFEncoder(r)
         >>> e.polynomial_clauses(r.variable(0)*r.variable(1)*r.variable(2))
@@ -141,7 +141,7 @@ def get_sign(val):
 
     def dimacs_encode_polynomial(self, p):
         """
-         >>> from brial import *
+         >>> from sage.rings.polynomial.pbori.brial import *
          >>> d=dict()
          >>> r = declare_ring(["x", "y", "z"], d)
          >>> e = CNFEncoder(r)
@@ -156,7 +156,7 @@ def dimacs_encode_polynomial(self, p):
 
     def dimacs_cnf(self, polynomial_system):
         r"""
-        >>> from brial import *
+        >>> from sage.rings.polynomial.pbori.brial import *
         >>> r = declare_ring(["x", "y", "z"], dict())
         >>> e = CNFEncoder(r)
         >>> e.dimacs_cnf([r.variable(0)*r.variable(1)*r.variable(2)])
@@ -182,7 +182,7 @@ class CryptoMiniSatEncoder(CNFEncoder):
 
     def dimacs_encode_polynomial(self, p):
         r"""
-         >>> from brial import *
+         >>> from sage.rings.polynomial.pbori.brial import *
          >>> d=dict()
          >>> r = declare_ring(["x", "y", "z"], d)
          >>> e = CryptoMiniSatEncoder(r)
@@ -216,7 +216,7 @@ def dimacs_encode_polynomial(self, p):
 
     def dimacs_cnf(self, polynomial_system):
         r"""
-            >>> from brial import *
+            >>> from sage.rings.polynomial.pbori.brial import *
             >>> r = declare_ring(["x", "y", "z"], dict())
             >>> e = CryptoMiniSatEncoder(r)
             >>> e.dimacs_cnf([r.variable(0)*r.variable(1)*r.variable(2)])

src/sage/rings/polynomial/pbori/context.py

@@ -25,7 +25,7 @@ class FactoryContext(object):
 
     Example:
     >>> r = Ring(1000)
-    >>> from brial import Variable
+    >>> from sage.rings.polynomial.pbori.brial import Variable
     >>> def var(idx): return Variable(idx, r)
     >>> with FactoryContext(Variable, var):
     ...     print Variable(17)
@@ -65,7 +65,7 @@ class RingContext(object):
 
     Example:
     >>> r = Ring(1000)
-    >>> from brial import Variable
+    >>> from sage.rings.polynomial.pbori.brial import Variable
     >>> print Variable(17, r)
     x(17)
     >>> with RingContext(r):

src/sage/rings/polynomial/pbori/easy_polynomials.py

@@ -5,7 +5,7 @@
 def easy_linear_polynomials(p):
     """ Get linear polynomials implied by given polynomial.
 
-    >>> from brial.frontend import *
+    >>> from sage.rings.polynomial.pbori.brial.frontend import *
     >>> easy_linear_polynomials(x(1)*x(2) + 1)
     [x(1) + 1, x(2) + 1]
     >>> easy_linear_polynomials(x(1)*x(2) + 0)
@@ -28,7 +28,7 @@ def easy_linear_polynomials_via_interpolation(p):
     """ Get linear polynomials implied by given polynomial using interpolation
     of the variety.
 
-    >>> from brial.frontend import *
+    >>> from sage.rings.polynomial.pbori.brial.frontend import *
     >>> easy_linear_polynomials_via_interpolation(x(1)*x(2) + 1)
     [x(1) + 1, x(2) + 1]
     >>> easy_linear_polynomials_via_interpolation(x(1)*x(2) + 0)

src/sage/rings/polynomial/pbori/fglm.py

@@ -25,7 +25,7 @@ def fglm(I, from_ring, to_ring):
     converts *reduced* Groebner Basis in from_ring to a GroebnerBasis in to_ring.
     It acts independend of the global ring, which is restored at the end of the
     computation,
-    >>> from brial.PyPolyBoRi import OrderCode
+    >>> from sage.rings.polynomial.pbori.brial.PyPolyBoRi import OrderCode
     >>> dp_asc = OrderCode.dp_asc
     >>> r=declare_ring(['x','y','z'],dict())
     >>> old_ring = r
@@ -44,9 +44,9 @@ def fglm(I, from_ring, to_ring):
 def vars_real_divisors(monomial, monomial_set):
     """
     returns all elements of of monomial_set, which result multiplied by a variable in monomial.
-    >>> from brial.PyPolyBoRi import OrderCode
+    >>> from sage.rings.polynomial.pbori.brial.PyPolyBoRi import OrderCode
     >>> dp_asc = OrderCode.dp_asc
-    >>> from brial.PyPolyBoRi import Ring
+    >>> from sage.rings.polynomial.pbori.brial.PyPolyBoRi import Ring
     >>> r=Ring(1000)
     >>> x = r.variable
     >>> b=BooleSet([x(1)*x(2),x(2)])
@@ -60,7 +60,7 @@ def vars_real_divisors(monomial, monomial_set):
 def m_k_plus_one(completed_elements, variables):
     """ calculates $m_{k+1}$ from the FGLM algorithm as described in Wichmanns diploma thesis
     It would be nice to be able to efficiently extract the smallest term of a polynomial
-    >>> from brial.PyPolyBoRi import OrderCode
+    >>> from sage.rings.polynomial.pbori.brial.PyPolyBoRi import OrderCode
     >>> dp_asc = OrderCode.dp_asc
     >>> r=Ring(1000)
     >>> x = r.variable

src/sage/rings/polynomial/pbori/frontend.py

@@ -17,7 +17,7 @@
 >>> x(9999) + x(9999)
 0
 
->>> from brial.frontend import *
+>>> from sage.rings.polynomial.pbori.brial.frontend import *
 >>> context = dict(globals())
 >>> polybori_start(context) # doctest: +ELLIPSIS
 ipbori...

src/sage/rings/polynomial/pbori/gbcore.py

@@ -387,7 +387,7 @@ def variety_size_from_gb(I):
 
 def other_ordering_pre(I, option_set, kwds):
     """
-    >>> from brial.blocks import declare_ring
+    >>> from sage.rings.polynomial.pbori.brial.blocks import declare_ring
     >>> r = declare_ring(['x0', 'x1', 'x2', 'x3', 'x4'], globals())
     >>> id = [x1*x3 + x1 + x2*x3 + x3 + x4, x0*x3 + x0 + x1*x2 + x2 + 1,  x1*x3 + x1*x4 + x3*x4 + x4 + 1, x0*x2 + x0*x4 + x1 + x3 + x4]
     >>> groebner_basis(id)

src/sage/rings/polynomial/pbori/intersect.py

@@ -16,8 +16,8 @@ def intersect(i, j, **gb_opts):
     This functions intersects two ideals. The first ring variable is used as helper variable for this
     intersection. It is assumed, that it doesn't occur in the ideals, and that we have an elimination ordering
     for this variables. Both assumptions are checked.
-    >>> from brial.frontend import declare_ring
-    >>> from brial import Block
+    >>> from sage.rings.polynomial.pbori.brial.frontend import declare_ring
+    >>> from sage.rings.polynomial.pbori.brial import Block
     >>> r=declare_ring(Block("x", 1000), globals())
     >>> x = r.variable
     >>> intersect([x(1),x(2)+1],[x(1),x(2)])

src/sage/rings/polynomial/pbori/intpolys.py

@@ -33,7 +33,7 @@ def __coerce__(self, other):
 
     def __add__(self, other):
         """
-        >>> from brial import *
+        >>> from sage.rings.polynomial.pbori.brial import *
         >>> r= declare_ring([Block("x",1000)], globals()) # doctest: +ELLIPSIS
         >>> p=IntegerPolynomial(x(1))
         >>> p

src/sage/rings/polynomial/pbori/ll.py

@@ -209,7 +209,7 @@ def llnf(p):
 class RingMap(object):
     """Define a mapping between two rings by common variable names.
 
-    >>> from brial.frontend import *
+    >>> from sage.rings.polynomial.pbori.brial.frontend import *
     >>> to_ring = declare_ring([Block("x", 10)], globals())
     >>> from_ring = declare_ring([Block("y", 5), Block("x", 10)], globals())
     >>> mapping = RingMap(to_ring, from_ring)
@@ -232,7 +232,7 @@ class RingMap(object):
     def __init__(self, to_ring, from_ring):
         """Initialize map by two given rings.
 
-        >>> from brial.frontend import *
+        >>> from sage.rings.polynomial.pbori.brial.frontend import *
         >>> to_ring = declare_ring([Block("x", 10)], globals())
         >>> from_ring = declare_ring([Block("y", 5), Block("x", 10)], globals())
         >>> mapping = RingMap(to_ring, from_ring)
@@ -268,7 +268,7 @@ def indices(vars):
     def __call__(self, poly):
         """Execute the map to change rings.
 
-        >>> from brial.frontend import *
+        >>> from sage.rings.polynomial.pbori.brial.frontend import *
         >>> to_ring = declare_ring([Block("x", 10)], globals())
         >>> from_ring = declare_ring([Block("y", 5), Block("x", 10)], globals())
         >>> mapping = RingMap(to_ring, from_ring)
@@ -280,7 +280,7 @@ def __call__(self, poly):
     def invert(self, poly):
         """Inverted map to initial ring.
 
-        >>> from brial.frontend import *
+        >>> from sage.rings.polynomial.pbori.brial.frontend import *
         >>> to_ring = declare_ring([Block("x", 10)], globals())
         >>> from_ring = declare_ring([Block("y", 5), Block("x", 10)], globals())
         >>> mapping = RingMap(to_ring, from_ring)

src/sage/rings/polynomial/pbori/nf.py

@@ -643,7 +643,7 @@ def symmGB_F2_C(G, opt_exchange=True,
 
 def normal_form(poly, ideal, reduced=True):
     """ Simple normal form computation of a polynomial  against an ideal.
-    >>> from brial import declare_ring, normal_form
+    >>> from sage.rings.polynomial.pbori.brial import declare_ring, normal_form
     >>> r=declare_ring(['x','y'], globals())
     >>> normal_form(x+y, [y],reduced=True)
     x

src/sage/rings/polynomial/pbori/parallel.py

@@ -40,7 +40,7 @@ def to_fast_pickable(l):
         Each code c refers to the c-2-th position in the conversion list, if c >=2, else to
         the corresponding Boolean constant if c in {0, 1}
     EXAMPLES:
-        >>> from brial.PyPolyBoRi import Ring
+        >>> from sage.rings.polynomial.pbori.brial.PyPolyBoRi import Ring
         >>> r=Ring(1000)
         >>> x=r.variable
         >>> to_fast_pickable([Polynomial(1, r)])
@@ -109,7 +109,7 @@ def from_fast_pickable(l, r):
     OUTPUT:
         a list of Boolean polynomials
     EXAMPLES:
-        >>> from brial.PyPolyBoRi import Ring
+        >>> from sage.rings.polynomial.pbori.brial.PyPolyBoRi import Ring
         >>> r=Ring(1000)
         >>> x = r.variable
         >>> from_fast_pickable([[1], []], r)
@@ -257,7 +257,7 @@ def groebner_basis_first_finished(I, *l):
         - tries to compute groebner_basis(I, **kwd) for kwd in l
         - returns the result of the first terminated computation
     EXAMPLES:
-        >>> from brial.PyPolyBoRi import Ring
+        >>> from sage.rings.polynomial.pbori.brial.PyPolyBoRi import Ring
         >>> r=Ring(1000)
         >>> ideal = [r.variable(1)*r.variable(2)+r.variable(2)+r.variable(1)]
         >>> #groebner_basis_first_finished(ideal, dict(heuristic=True), dict(heuristic=False))