Ticket #13849: trac13849_deprecate_degrevlex.patch

File trac13849_deprecate_degrevlex.patch, 10.7 KB (added by malb, 10 years ago)
  • sage/crypto/mq/sr.py

    # HG changeset patch
    # User Martin Albrecht <martinralbrecht@googlemail.com>
    # Date 1358326333 0
    # Node ID cb7a2ea0589d9b8abd4dc77172a2ce4ee1ca515f
    # Parent  af66881f97b3ebac2b500a5e3eb65ef0d5b7b268
    #13849 deprecate degrevlex
    
    diff --git a/sage/crypto/mq/sr.py b/sage/crypto/mq/sr.py
    a b  
    16711671            sage: sr = mq.SR(2, 1, 1, 4)
    16721672            sage: sr.block_order()
    16731673            Block term order with blocks:
    1674             (Degree reverse lexicographic term order of length 16,
    1675              Degree reverse lexicographic term order of length 16,
    1676              Degree reverse lexicographic term order of length 4)
     1674            (Degree lexicographic term order of length 16,
     1675             Degree lexicographic term order of length 16,
     1676             Degree lexicographic term order of length 4)
    16771677
    16781678        ::
    16791679
     
    16821682            Polynomial Ring
    16831683              Base Ring : Finite Field in a of size 2^4
    16841684                   Size : 36 Variables
    1685                Block  0 : Ordering : degrevlex
     1685               Block  0 : Ordering : deglex
    16861686                          Names    : k200, k201, k202, k203, x200, x201, x202, x203, w200, w201, w202, w203, s100, s101, s102, s103
    1687                Block  1 : Ordering : degrevlex
     1687               Block  1 : Ordering : deglex
    16881688                          Names    : k100, k101, k102, k103, x100, x101, x102, x103, w100, w101, w102, w103, s000, s001, s002, s003
    1689                Block  2 : Ordering : degrevlex
     1689               Block  2 : Ordering : deglex
    16901690                          Names    : k000, k001, k002, k003
    16911691        """
    16921692        r = self.r
     
    16961696
    16971697        T = None
    16981698        for _n in range(n):
    1699             T = TermOrder('degrevlex', r*e + 3*r*c*e ) + T
    1700 
    1701         T += TermOrder('degrevlex', r*c*e)
     1699            T = TermOrder('deglex', r*e + 3*r*c*e ) + T
     1700
     1701        T += TermOrder('deglex', r*c*e)
    17021702
    17031703        return T
    17041704
     
    17381738            Polynomial Ring
    17391739              Base Ring : Finite Field in a of size 2^4
    17401740                   Size : 36 Variables
    1741                Block  0 : Ordering : degrevlex
     1741               Block  0 : Ordering : deglex
    17421742                          Names    : k200, k201, k202, k203, x200, x201, x202, x203, w200, w201, w202, w203, s100, s101, s102, s103
    1743                Block  1 : Ordering : degrevlex
     1743               Block  1 : Ordering : deglex
    17441744                          Names    : k100, k101, k102, k103, x100, x101, x102, x103, w100, w101, w102, w103, s000, s001, s002, s003
    1745                Block  2 : Ordering : degrevlex
     1745               Block  2 : Ordering : deglex
    17461746                          Names    : k000, k001, k002, k003
    17471747        """
    17481748        r = self.r
  • sage/rings/polynomial/multi_polynomial_sequence.py

    diff --git a/sage/rings/polynomial/multi_polynomial_sequence.py b/sage/rings/polynomial/multi_polynomial_sequence.py
    a b  
    377377            Polynomial Ring
    378378             Base Ring : Finite Field of size 2
    379379                  Size : 20 Variables
    380               Block  0 : Ordering : degrevlex
     380              Block  0 : Ordering : deglex
    381381                         Names    : k100, k101, k102, k103, x100, x101, x102, x103, w100, w101, w102, w103, s000, s001, s002, s003
    382               Block  1 : Ordering : degrevlex
     382              Block  1 : Ordering : deglex
    383383                         Names    : k000, k001, k002, k003
    384384        """
    385385        return self._ring
  • sage/rings/polynomial/pbori.pyx

    diff --git a/sage/rings/polynomial/pbori.pyx b/sage/rings/polynomial/pbori.pyx
    a b  
    294294
    295295    ::
    296296
    297         sage: R = BooleanPolynomialRing(3,'x',order='degrevlex')
     297        sage: R = BooleanPolynomialRing(3,'x',order='deglex')
    298298        sage: R.term_order()
    299         Degree reverse lexicographic term order
     299        Degree lexicographic term order
    300300
    301301    TESTS::
    302302
    303         sage: P.<x,y> = BooleanPolynomialRing(2,order='degrevlex')
    304         sage: x > y
    305         True
    306 
    307     ::
    308 
    309         sage: P.<x0, x1, x2, x3> = BooleanPolynomialRing(4,order='degrevlex(2),degrevlex(2)')
     303        sage: P.<x0, x1, x2, x3> = BooleanPolynomialRing(4,order='deglex(2),deglex(2)')
    310304        sage: x0 > x1
    311305        True
    312306        sage: x2 > x3
     
    377371            raise ValueError, "Only order keys " + \
    378372                  ', '.join(order_mapping.keys()) + " are supported."
    379373
     374
     375        if pb_order_code in (pbdp, pbblock_dp):
     376            from sage.misc.superseded import deprecation
     377            deprecation(13849, "using 'degrevlex' in Boolean polynomial rings is deprecated. If needed, reverse the order of variables manually and use 'degneglex'")
     378
    380379        if order.is_block_order():
    381380            if pb_order_code is pblp:
    382                 raise ValueError, "Only deglex and degrevlex are supported for block orders."
     381                raise ValueError, "Only deglex and degneglex are supported for block orders."
    383382            elif pb_order_code is pbdlex:
    384383                pb_order_code = pbblock_dlex
    385384            elif pb_order_code is pbdp_asc:
     
    389388            for i in range(1, len(order.blocks())):
    390389                if order[0].name() != order[i].name():
    391390                    raise ValueError, "Each block must have the same order " + \
    392                           "type (deglex, degneglex or degrevlex) for block orders."
     391                          "type (deglex and degneglex) for block orders."
    393392       
    394393        if pb_order_code is pbdp:
    395394            for i from 0 <= i < n:
     
    504503       
    505504        TESTS::
    506505       
    507             sage: P.<x,y,z> = BooleanPolynomialRing(3, order='dp')
     506            sage: P.<x,y,z> = BooleanPolynomialRing(3, order='deglex')
    508507            sage: P.gen(0)
    509508            x
    510509        """
     
    534533            sage: P.gens()
    535534            (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)
    536535       
    537         TESTS::
    538        
    539             sage: P.<x,y,z> = BooleanPolynomialRing(3,order='degrevlex')
    540             sage: P.gens()
    541             (x, y, z)
    542536        """
    543537        return tuple([new_BP_from_PBVar(self,
    544538            self._pbring.variable(self.pbind[i])) \
     
    758752            sage: P(x)
    759753            x
    760754
    761         Test conversion between 'degrevlex' and 'lex'::
    762 
    763             sage: B.<a,b,c> = BooleanPolynomialRing(order='lex')
    764             sage: P.<a,b,c> = BooleanPolynomialRing(order='degrevlex')
    765             sage: B(P('a'))
    766             a
    767             sage: P(B('a'))
    768             a
    769 
    770755        Test that #10797 is really fixed::
    771756
    772757            sage: B.<a,b,c,d,e,f> = BooleanPolynomialRing()
     
    904889            sage: p = x^3+2*x^2+x+1
    905890            sage: P(p)
    906891            x
    907 
    908         Check that trac ticket #13202 is fixed:
    909 
    910             sage: B.<a,b,c,d> = BooleanPolynomialRing(order='degrevlex')
    911             sage: P.<c,d> = BooleanPolynomialRing(order='lex')
    912             sage: P(B(c))
    913             c
    914892        """
    915893        cdef int i
    916894
     
    15251503       
    15261504        TESTS::
    15271505       
    1528             sage: P.<x,y,z> = BooleanPolynomialRing(3, order='dp')
     1506            sage: P.<x,y,z> = BooleanPolynomialRing(3, order='deglex')
    15291507            sage: P.variable(0)
    15301508            x
    15311509        """
     
    17921770        [z, x]
    17931771        sage: sage.rings.polynomial.pbori.get_var_mapping(P, x^2)
    17941772        [None, x]
    1795 
    1796     Check that ticket #13202 is fixed::
    1797 
    1798         sage: B.<a,b,c,d> = BooleanPolynomialRing(order='degrevlex')
    1799         sage: P.<c,d> = BooleanPolynomialRing(order='lex')
    1800         sage: sage.rings.polynomial.pbori.get_var_mapping(B, P)
    1801         [c, d]
    18021773    """
    18031774
    18041775    my_names = list(ring._names) # we need .index(.)
     
    31873158       
    31883159        ::
    31893160       
    3190             sage: P.<x,y,z> = BooleanPolynomialRing(3, order='degrevlex')
     3161            sage: P.<x,y,z> = BooleanPolynomialRing(3, order='deglex')
    31913162            sage: p = x + z + x*y + y*z + x*y*z
    31923163            sage: list(iter(p))
    3193             [z*y*x, y*x, z*y, x, z]
     3164            [x*y*z, x*y, y*z, x, z]
    31943165       
    31953166        TESTS::
    31963167       
     
    38373808       
    38383809        ::
    38393810       
    3840             sage: P.<a,b,c> = BooleanPolynomialRing(3,order='degrevlex')
     3811            sage: P.<a,b,c> = BooleanPolynomialRing(3,order='deglex')
    38413812            sage: f = a + c*b
    38423813            sage: f.monomials()
    3843             [c*b, a]
     3814            [b*c, a]
    38443815            sage: P.zero().monomials()
    38453816            []
    38463817        """
     
    38763847            sage: f.terms()
    38773848            [a, b*c]
    38783849       
    3879             sage: P.<a,b,c> = BooleanPolynomialRing(3,order='degrevlex')
     3850            sage: P.<a,b,c> = BooleanPolynomialRing(3,order='deglex')
    38803851            sage: f = a + c*b
    38813852            sage: f.terms()
    3882             [c*b, a]
     3853            [b*c, a]
    38833854        """
    38843855        return list(self)
    38853856
     
    44604431       
    44614432        EXAMPLE::
    44624433       
    4463             sage: B.<a,b,c,d> = BooleanPolynomialRing(4,order='degrevlex')
     4434            sage: B.<a,b,c,d> = BooleanPolynomialRing(4,order='deglex')
    44644435            sage: f = (a*b + 1)*(c + 1)
    44654436            sage: f.reducible_by(d)
    44664437            False
     
    50645035
    50655036        EXAMPLES::
    50665037
    5067             sage: B.<x,y,z> = BooleanPolynomialRing(order='degrevlex')
     5038            sage: B.<x,y,z> = BooleanPolynomialRing(order='deglex')
    50685039            sage: id = B.ideal((x + y)*(y + z), x*y*z)
    50695040            sage: id._groebner_basis()
    5070             [z*x, y*x + z*y + y]
     5041            [x*z, x*y + y*z + y]
    50715042
    50725043            sage: B.<x,y,z> = BooleanPolynomialRing(order='deglex')
    50735044            sage: id = B.ideal((x + y)*(y + z), x*y*z)
  • sage/rings/polynomial/polynomial_ring_constructor.py

    diff --git a/sage/rings/polynomial/polynomial_ring_constructor.py b/sage/rings/polynomial/polynomial_ring_constructor.py
    a b  
    622622        (Degree lexicographic term order of length 3,
    623623         Degree lexicographic term order of length 2)
    624624
    625         sage: R = BooleanPolynomialRing(3,'x',order='degrevlex')
     625        sage: R = BooleanPolynomialRing(3,'x',order='degneglex')
    626626        sage: R.term_order()
    627         Degree reverse lexicographic term order
     627        Degree negative lexicographic term order
    628628
    629629        sage: BooleanPolynomialRing(names=('x','y'))
    630630        Boolean PolynomialRing in x, y
     
    634634
    635635    TESTS::
    636636
    637         sage: P.<x,y> = BooleanPolynomialRing(2,order='degrevlex')
     637        sage: P.<x,y> = BooleanPolynomialRing(2,order='deglex')
    638638        sage: x > y
    639639        True
    640640
    641         sage: P.<x0, x1, x2, x3> = BooleanPolynomialRing(4,order='degrevlex(2),degrevlex(2)')
     641        sage: P.<x0, x1, x2, x3> = BooleanPolynomialRing(4,order='deglex(2),deglex(2)')
    642642        sage: x0 > x1
    643643        True
    644644        sage: x2 > x3