Ticket #3397: sage-3397-apply_after-3397-2008-07-30-main.patch

File sage-3397-apply_after-3397-2008-07-30-main.patch, 18.0 KB (added by was, 11 years ago)
  • sage/algebras/steenrod_algebra_bases.py

    # HG changeset patch
    # User William Stein <wstein@gmail.com>
    # Date 1218342244 25200
    # Node ID c2ae286882023dd48faae0b04958ee49d9ba8d1a
    # Parent  801dec24016e61b5a1e6717008fc303e8e09792c
    Fixed a few obvious typos in latex formating, and renamed the optional parameter LaTeX to latex, since variable naming conventions in sage don't allow LaTeX for a parameter name (plus it is inconsistent the the latex command in sage, which is named latex not LaTeX).
    
    diff -r 801dec24016e -r c2ae28688202 sage/algebras/steenrod_algebra_bases.py
    a b def xi_degrees(n,p=2): 
    707707    OUTPUT:
    708708        list -- list of integers
    709709
    710     When p=2: decreasing list of the degrees of the $\xi_i$'s with
     710    When $p=2$: decreasing list of the degrees of the $\xi_i$'s with
    711711    degree at most n.
    712712   
    713713    At odd primes: decreasing list of these degrees, each divided
    714     by 2(p-1).
     714    by $2(p-1)$.
    715715
    716716    EXAMPLES:
    717717        sage: sage.algebras.steenrod_algebra_bases.xi_degrees(17)
    def atomic_basis(n, basis, long=False): 
    963963    Arnon's A basis, the $P^s_t$-bases, and the commutator bases.
    964964    (All of these bases are constructed similarly, hence their
    965965    constructions have been consolidated into a single function.
    966     Also, See the documentation for 'steenrod_algebra_basis' for
     966    Also, see the documentation for 'steenrod_algebra_basis' for
    967967    descriptions of them.)
    968968
    969969    EXAMPLES:
  • sage/algebras/steenrod_algebra_element.py

    diff -r 801dec24016e -r c2ae28688202 sage/algebras/steenrod_algebra_element.py
    a b not %s" % (poly, poly.parent().prime, p) 
    908908        and change bases.  Store the result in self._raw[basis], for later
    909909        use; this way, an element only needs to be converted once.
    910910        """
    911         def is_power_of_two(n):
    912             """
    913             True if and only n is a power of 2
    914             """
    915             while n != 0 and n%2 == 0:
    916                 n = n >> 1
    917             return n == 1
    918 
     911        from sage.rings.arith import is_power_of_two
    919912        from steenrod_algebra import _steenrod_serre_cartan_basis_names, \
    920913            _steenrod_milnor_basis_names, get_basis_name
    921914        from steenrod_algebra_bases import milnor_convert
    not %s" % (poly, poly.parent().prime, p) 
    12971290        that $x$ is in $F_k(A)$ and not in $F_{k+1}(A)$.  According to
    12981291        Theorem 2.6 in May's thesis [May], the weight of a Milnor
    12991292        basis element is computed as follows: first, to compute the
    1300         weight of $P(r_1,r2, ...)$, write each $r_i$ in base
     1293        weight of $P(r_1,r_2, ...)$, write each $r_i$ in base
    13011294        $p$ as $r_i = \sum_j p^j r_{ij}$.  Then each nonzero binary
    13021295        digit $r_{ij}$ contributes $i$ to the weight: the weight is
    13031296        $\sum_{i,j} i r_{ij}$.  When $p$ is odd, the weight of $Q_i$
    13041297        is $i+1$, so the weight of a product $Q_{i_1} Q_{i_2} ...$ is
    13051298        equal $(i_1+1) + (i_2+1) + ...$.  Then the weight of $Q_{i_1}
    1306         Q_{i_2} ...P(r_1,r2, ...)$ is the sum of $(i_1+1) +
     1299        Q_{i_2} ...P(r_1,r_2, ...)$ is the sum of $(i_1+1) +
    13071300        (i_2+1) + ...$ and $\sum_{i,j} i r_{ij}$.
    13081301       
    13091302        The weight of a sum of basis elements is the minimum of the
    not %s" % (poly, poly.parent().prime, p) 
    15291522            """
    15301523            from steenrod_algebra_bases import steenrod_algebra_basis
    15311524            return sum(steenrod_algebra_basis(n,'milnor',p=p))
     1525
    15321526        from sage.algebras.steenrod_algebra import SteenrodAlgebra
    15331527        from steenrod_algebra_bases import milnor_convert
    15341528        result = 0
    not %s" % (poly, poly.parent().prime, p) 
    16271621        if len(self._raw['milnor']) == 0:
    16281622            return "0"
    16291623        else:
    1630             return string_rep(self,LaTeX=True)
     1624            return string_rep(self,latex=True)
    16311625
    16321626
    16331627    def __iter__(self):
    admissible = serre_cartan 
    18781872
    18791873## string representations
    18801874
    1881 def string_rep(element, LaTeX=False, sort=True):
     1875def string_rep(element, latex=False, sort=True):
    18821876    """
    18831877    String representation of element.
    18841878
    18851879    INPUT:
    18861880        element -- element of the Steenrod algebra
    1887         LaTeX -- boolean (optional, default False), if True, output LaTeX string
     1881        latex -- boolean (optional, default False), if True, output LaTeX string
    18881882        sort -- boolean (optional, default True), if True, sort output
    18891883
    18901884    OUTPUT:
    18911885        string -- string representation of element in current basis
    18921886
    1893     If LaTeX is True, output a string suitable for LaTeX; otherwise,
     1887    If latex is True, output a string suitable for LaTeX; otherwise,
    18941888    output a plain string.  If sort is True, sort element left
    18951889    lexicographically; otherwise, no sorting is done, and so the
    18961890    order in which the summands are printed may be unpredictable.
    def string_rep(element, LaTeX=False, sor 
    19041898        Sq^{10} Sq^{4} + Sq^{11} Sq^{2} Sq^{1} + Sq^{12} Sq^{2} + Sq^{13} Sq^{1}
    19051899        + Sq^{14}'
    19061900        sage: b = Sq(0,2)
    1907         sage: string_rep(A(b),LaTeX=True)
     1901        sage: string_rep(A(b),latex=True)
    19081902        '\\text{Sq}^{4} \\text{Sq}^{2} + \\text{Sq}^{5} \\text{Sq}^{1} +
    19091903        \\text{Sq}^{6}'
    19101904        sage: A_wood_z = SteenrodAlgebra(2, 'woodz')
    def string_rep(element, LaTeX=False, sor 
    19201914        sage: string_rep(SteenrodAlgebra(2, 'pst_llex')(a))
    19211915        'P^{1}_{3}'
    19221916        sage: Ac = SteenrodAlgebra(2, 'comm_revz')
    1923         sage: string_rep(Ac(a),LaTeX=True,sort=False)
     1917        sage: string_rep(Ac(a),latex=True,sort=False)
    19241918        'c_{0,2} c_{0,3} c_{2,1} + c_{1,3} + c_{0,1} c_{1,1} c_{0,3} c_{2,1}'
    1925         sage: string_rep(Ac(a),LaTeX=True)
     1919        sage: string_rep(Ac(a),latex=True)
    19261920        'c_{0,1} c_{1,1} c_{0,3} c_{2,1} + c_{0,2} c_{0,3} c_{2,1} + c_{1,3}'
    19271921        sage: string_rep(a)
    19281922        'Sq(0,0,2)'
    1929         sage: string_rep(a,LaTeX=True)
     1923        sage: string_rep(a,latex=True)
    19301924        '\\text{Sq}(0,0,2)'
    19311925
    19321926    Some odd primary examples:
    def string_rep(element, LaTeX=False, sor 
    19341928        sage: a = A5.P(5,1); b = A5.Q(0,1,3)
    19351929        sage: string_rep(b)
    19361930        'Q_0 Q_1 Q_3'
    1937         sage: string_rep(a, LaTeX=True)
     1931        sage: string_rep(a, latex=True)
    19381932        '\\mathcal{P}(5,1)'
    19391933        sage: A5sc = SteenrodAlgebra(5, 'serre-cartan')
    19401934        sage: string_rep(A5sc(a))
    def string_rep(element, LaTeX=False, sor 
    19801974            coeff = str(dict[mono]) + " "
    19811975        else:
    19821976            coeff = ""
    1983         output = output + coeff + mono_to_string(mono, LaTeX,
     1977        output = output + coeff + mono_to_string(mono, latex,
    19841978                                                 p=element._prime) + " + "
    19851979    return output.strip(" +")
    19861980
    19871981
    1988 def milnor_mono_to_string(mono,LaTeX=False,p=2):
     1982def milnor_mono_to_string(mono,latex=False,p=2):
    19891983    """
    19901984    String representation of element of the Milnor basis.
    19911985
    def milnor_mono_to_string(mono,LaTeX=Fal 
    19951989        mono -- if $p=2$, tuple of non-negative integers (a,b,c,...);
    19961990                if $p>2$, pair of tuples of non-negative integers
    19971991                ((e0, e1, e2, ...), (r1, r2, ...))
    1998         LaTeX -- boolean (optional, default False), if true, output LaTeX string
     1992        latex -- boolean (optional, default False), if true, output LaTeX string
    19991993        p -- positive prime number (optional, default 2)
    20001994
    20011995    OUTPUT:
    def milnor_mono_to_string(mono,LaTeX=Fal 
    20082002        sage: from sage.algebras.steenrod_algebra_element import milnor_mono_to_string
    20092003        sage: milnor_mono_to_string((1,2,3,4))
    20102004        'Sq(1,2,3,4)'
    2011         sage: milnor_mono_to_string((1,2,3,4),LaTeX=True)
     2005        sage: milnor_mono_to_string((1,2,3,4),latex=True)
    20122006        '\\text{Sq}(1,2,3,4)'
    20132007        sage: milnor_mono_to_string(((1,0), (2,3,1)), p=3)
    20142008        'Q_1 Q_0 P(2,3,1)'
    2015         sage: milnor_mono_to_string(((1,0), (2,3,1)), LaTeX=True, p=3)
     2009        sage: milnor_mono_to_string(((1,0), (2,3,1)), latex=True, p=3)
    20162010        'Q_{1} Q_{0} \\mathcal{P}(2,3,1)'
    20172011
    20182012    The empty tuple represents the unit element Sq(0) (or P(0) at an odd prime):
    def milnor_mono_to_string(mono,LaTeX=Fal 
    20212015        sage: milnor_mono_to_string((), p=5)
    20222016        'P(0)'
    20232017    """
    2024     if LaTeX:
     2018    if latex:
    20252019        if p == 2:
    20262020            sq = "\\text{Sq}"
    20272021            P = "\\text{Sq}"
    def milnor_mono_to_string(mono,LaTeX=Fal 
    20452039            string = ""
    20462040            if len(mono[0]) > 0:
    20472041                for e in mono[0]:
    2048                     if LaTeX:
     2042                    if latex:
    20492043                        string = string + "Q_{" + str(e) + "} "
    20502044                    else:
    20512045                        string = string + "Q_" + str(e) + " "
    def milnor_mono_to_string(mono,LaTeX=Fal 
    20572051        return string.strip(" ")
    20582052   
    20592053
    2060 def serre_cartan_mono_to_string(mono,LaTeX=False,p=2):
     2054def serre_cartan_mono_to_string(mono,latex=False,p=2):
    20612055    r"""
    20622056    String representation of element of the Serre-Cartan basis.
    20632057
    def serre_cartan_mono_to_string(mono,LaT 
    20672061        mono -- tuple of positive integers (a,b,c,...) when $p=2$, or tuple
    20682062                (e0, n1, e1, n2, ...) when $p>2$, where each ei is 0 or 1, and
    20692063                each ni is positive
    2070         LaTeX -- boolean (optional, default False), if true, output LaTeX string
     2064        latex -- boolean (optional, default False), if true, output LaTeX string
    20712065        p -- positive prime number (optional, default 2)
    20722066
    20732067    OUTPUT:
    def serre_cartan_mono_to_string(mono,LaT 
    20812075        sage: from sage.algebras.steenrod_algebra_element import serre_cartan_mono_to_string
    20822076        sage: serre_cartan_mono_to_string((1,2,3,4))
    20832077        'Sq^{1} Sq^{2} Sq^{3} Sq^{4}'
    2084         sage: serre_cartan_mono_to_string((1,2,3,4),LaTeX=True)
     2078        sage: serre_cartan_mono_to_string((1,2,3,4),latex=True)
    20852079        '\\text{Sq}^{1} \\text{Sq}^{2} \\text{Sq}^{3} \\text{Sq}^{4}'
    20862080        sage: serre_cartan_mono_to_string((0,5,1,1,0), p=3)
    20872081        'P^{5} beta P^{1}'
    2088         sage: serre_cartan_mono_to_string((0,5,1,1,0), p=3, LaTeX=True)
     2082        sage: serre_cartan_mono_to_string((0,5,1,1,0), p=3, latex=True)
    20892083        '\\mathcal{P}^{5} \\beta \\mathcal{P}^{1}'
    20902084
    20912085    The empty tuple represents the unit element $Sq^0$ (or $P^0$ at an odd prime):
    def serre_cartan_mono_to_string(mono,LaT 
    20942088        sage: serre_cartan_mono_to_string((), p=7)
    20952089        'P^{0}'
    20962090    """
    2097     if LaTeX:
     2091    if latex:
    20982092        if p == 2:
    20992093            sq = "\\text{Sq}"
    21002094            P = "\\text{Sq}"
    def serre_cartan_mono_to_string(mono,LaT 
    21202114                from sage.misc.functional import is_even
    21212115                if is_even(index):
    21222116                    if n == 1:
    2123                         if LaTeX:
     2117                        if latex:
    21242118                            string = string + "\\beta "
    21252119                        else:
    21262120                            string = string + "beta "
    def serre_cartan_mono_to_string(mono,LaT 
    21302124        return string.strip(" ")
    21312125
    21322126
    2133 def wood_mono_to_string(mono,LaTeX=False,p=2):
     2127def wood_mono_to_string(mono,latex=False,p=2):
    21342128    """
    21352129    String representation of element of Wood's Y and Z bases.
    21362130
    def wood_mono_to_string(mono,LaTeX=False 
    21462140        sage: from sage.algebras.steenrod_algebra_element import wood_mono_to_string
    21472141        sage: wood_mono_to_string(((1,2),(3,0)))
    21482142        'Sq^{14} Sq^{8}'
    2149         sage: wood_mono_to_string(((1,2),(3,0)),LaTeX=True)
     2143        sage: wood_mono_to_string(((1,2),(3,0)),latex=True)
    21502144        '\\text{Sq}^{14} \\text{Sq}^{8}'
    21512145
    21522146    The empty tuple represents the unit element Sq(0):
    21532147        sage: wood_mono_to_string(())
    21542148        'Sq(0)'
    21552149    """
    2156     if LaTeX:
     2150    if latex:
    21572151        sq = "\\text{Sq}"
    21582152    else:
    21592153        sq = "Sq"
    def wood_mono_to_string(mono,LaTeX=False 
    21672161        return string.strip(" ")
    21682162
    21692163
    2170 def wall_mono_to_string(mono,LaTeX=False,p=2):
     2164def wall_mono_to_string(mono,latex=False,p=2):
    21712165    """
    21722166    String representation of element of Wall's basis.
    21732167
    def wall_mono_to_string(mono,LaTeX=False 
    21832177        sage: from sage.algebras.steenrod_algebra_element import wall_mono_to_string
    21842178        sage: wall_mono_to_string(((1,2),(3,0)))
    21852179        'Q^{1}_{2} Q^{3}_{0}'
    2186         sage: wall_mono_to_string(((1,2),(3,0)),LaTeX=True)
     2180        sage: wall_mono_to_string(((1,2),(3,0)),latex=True)
    21872181        'Q^{1}_{2} Q^{3}_{0}'
    21882182
    21892183    The empty tuple represents the unit element Sq(0):
    21902184        sage: wall_mono_to_string(())
    21912185        'Sq(0)'
    21922186    """
    2193     if LaTeX:
     2187    if latex:
    21942188        sq = "\\text{Sq}"
    21952189    else:
    21962190        sq = "Sq"
    def wall_mono_to_string(mono,LaTeX=False 
    22042198        return string.strip(" ")
    22052199
    22062200
    2207 def wall_long_mono_to_string(mono,LaTeX=False,p=2):
     2201def wall_long_mono_to_string(mono,latex=False,p=2):
    22082202    """
    22092203    Alternate string representation of element of Wall's basis.
    22102204
    def wall_long_mono_to_string(mono,LaTeX= 
    22202214        sage: from sage.algebras.steenrod_algebra_element import wall_long_mono_to_string
    22212215        sage: wall_long_mono_to_string(((1,2),(3,0)))
    22222216        'Sq^{1} Sq^{2} Sq^{4} Sq^{8}'
    2223         sage: wall_long_mono_to_string(((1,2),(3,0)),LaTeX=True)
     2217        sage: wall_long_mono_to_string(((1,2),(3,0)),latex=True)
    22242218        '\\text{Sq}^{1} \\text{Sq}^{2} \\text{Sq}^{4} \\text{Sq}^{8}'
    22252219
    22262220    The empty tuple represents the unit element Sq(0):
    22272221        sage: wall_long_mono_to_string(())
    22282222        'Sq(0)'
    22292223    """
    2230     if LaTeX:
     2224    if latex:
    22312225        sq = "\\text{Sq}"
    22322226    else:
    22332227        sq = "Sq"
    def wall_long_mono_to_string(mono,LaTeX= 
    22412235        return string.strip(" ")
    22422236
    22432237
    2244 def arnonA_mono_to_string(mono,LaTeX=False,p=2):
     2238def arnonA_mono_to_string(mono,latex=False,p=2):
    22452239    """
    22462240    String representation of element of Arnon's A basis.
    22472241
    def arnonA_mono_to_string(mono,LaTeX=Fal 
    22572251        sage: from sage.algebras.steenrod_algebra_element import arnonA_mono_to_string
    22582252        sage: arnonA_mono_to_string(((1,2),(3,0)))
    22592253        'X^{1}_{2} X^{3}_{0}'
    2260         sage: arnonA_mono_to_string(((1,2),(3,0)),LaTeX=True)
     2254        sage: arnonA_mono_to_string(((1,2),(3,0)),latex=True)
    22612255        'X^{1}_{2} X^{3}_{0}'
    22622256
    22632257    The empty tuple represents the unit element Sq(0):
    22642258        sage: arnonA_mono_to_string(())
    22652259        'Sq(0)'
    22662260    """
    2267     if LaTeX:
     2261    if latex:
    22682262        sq = "\\text{Sq}"
    22692263    else:
    22702264        sq = "Sq"
    def arnonA_mono_to_string(mono,LaTeX=Fal 
    22782272        return string.strip(" ")
    22792273   
    22802274
    2281 def arnonA_long_mono_to_string(mono,LaTeX=False,p=2):
     2275def arnonA_long_mono_to_string(mono,latex=False,p=2):
    22822276    """
    22832277    Alternate string representation of element of Arnon's A basis.
    22842278
    def arnonA_long_mono_to_string(mono,LaTe 
    22942288        sage: from sage.algebras.steenrod_algebra_element import arnonA_long_mono_to_string
    22952289        sage: arnonA_long_mono_to_string(((1,2),(3,0)))
    22962290        'Sq^{8} Sq^{4} Sq^{2} Sq^{1}'
    2297         sage: arnonA_long_mono_to_string(((1,2),(3,0)),LaTeX=True)
     2291        sage: arnonA_long_mono_to_string(((1,2),(3,0)),latex=True)
    22982292        '\\text{Sq}^{8} \\text{Sq}^{4} \\text{Sq}^{2} \\text{Sq}^{1}'
    22992293
    23002294    The empty tuple represents the unit element Sq(0):
    23012295        sage: arnonA_long_mono_to_string(())
    23022296        'Sq(0)'
    23032297    """
    2304     if LaTeX:
     2298    if latex:
    23052299        sq = "\\text{Sq}"
    23062300    else:
    23072301        sq = "Sq"
    def arnonA_long_mono_to_string(mono,LaTe 
    23152309        return string.strip(" ")
    23162310   
    23172311
    2318 def pst_mono_to_string(mono,LaTeX=False,p=2):
     2312def pst_mono_to_string(mono,latex=False,p=2):
    23192313    r"""
    23202314    String representation of element of a $P^s_t$-basis.
    23212315
    def pst_mono_to_string(mono,LaTeX=False, 
    23312325        sage: from sage.algebras.steenrod_algebra_element import pst_mono_to_string
    23322326        sage: pst_mono_to_string(((1,2),(0,3)))
    23332327        'P^{1}_{2} P^{0}_{3}'
    2334         sage: pst_mono_to_string(((1,2),(0,3)),LaTeX=True)
     2328        sage: pst_mono_to_string(((1,2),(0,3)),latex=True)
    23352329        'P^{1}_{2} P^{0}_{3}'
    23362330
    23372331    The empty tuple represents the unit element Sq(0):
    23382332        sage: pst_mono_to_string(())
    23392333        'Sq(0)'
    23402334    """
    2341     if LaTeX:
     2335    if latex:
    23422336        sq = "\\text{Sq}"
    23432337    else:
    23442338        sq = "Sq"
    def pst_mono_to_string(mono,LaTeX=False, 
    23522346        return string.strip(" ")
    23532347
    23542348
    2355 def comm_mono_to_string(mono,LaTeX=False,p=2):
     2349def comm_mono_to_string(mono,latex=False,p=2):
    23562350    r"""
    23572351    String representation of element of a commutator basis.
    23582352
    def comm_mono_to_string(mono,LaTeX=False 
    23682362        sage: from sage.algebras.steenrod_algebra_element import comm_mono_to_string
    23692363        sage: comm_mono_to_string(((1,2),(0,3)))
    23702364        'c_{1,2} c_{0,3}'
    2371         sage: comm_mono_to_string(((1,2),(0,3)),LaTeX=True)
     2365        sage: comm_mono_to_string(((1,2),(0,3)),latex=True)
    23722366        'c_{1,2} c_{0,3}'
    23732367
    23742368    The empty tuple represents the unit element Sq(0):
    23752369        sage: comm_mono_to_string(())
    23762370        'Sq(0)'
    23772371    """
    2378     if LaTeX:
     2372    if latex:
    23792373        sq = "\\text{Sq}"
    23802374    else:
    23812375        sq = "Sq"
    def comm_mono_to_string(mono,LaTeX=False 
    23892383        return string.strip(" ")
    23902384
    23912385
    2392 def comm_long_mono_to_string(mono,LaTeX=False,p=2):
     2386def comm_long_mono_to_string(mono,latex=False,p=2):
    23932387    r"""
    23942388    Alternate string representation of element of a commutator basis.
    23952389
    def comm_long_mono_to_string(mono,LaTeX= 
    24052399        sage: from sage.algebras.steenrod_algebra_element import comm_long_mono_to_string
    24062400        sage: comm_long_mono_to_string(((1,2),(0,3)))
    24072401        's_{24} s_{124}'
    2408         sage: comm_long_mono_to_string(((1,2),(0,3)),LaTeX=True)
     2402        sage: comm_long_mono_to_string(((1,2),(0,3)),latex=True)
    24092403        's_{24} s_{124}'
    24102404
    24112405    The empty tuple represents the unit element Sq(0):
    24122406        sage: comm_long_mono_to_string(())
    24132407        'Sq(0)'
    24142408    """
    2415     if LaTeX:
     2409    if latex:
    24162410        sq = "\\text{Sq}"
    24172411    else:
    24182412        sq = "Sq"