Пример #1
0
    def __init__(self, p, depth, act_on_left=False, adjuster=None):
        self._dimension = 0  ## Hack!! Dimension was being called before it was intialised
        self._Rmod = ZpCA(p, depth - 1)  ## create Zp
        Module.__init__(self, base=self._Rmod)
        self.Element = BianchiDistributionElement
        self._R = ZZ
        self._p = p
        self._depth = depth
        self._pN = self._p**(depth - 1)
        self._cache_powers = dict()
        self._unset_coercions_used()

        ## Initialise monoid Sigma_0(p) + action; use Pollack-Stevens modular symbol code
        ## our_adjuster() is set above to allow different conventions
        if adjuster is None:
            adjuster = _default_adjuster()

        self._adjuster = adjuster

        ## Power series ring for representing distributions as strings
        self._repr_R = PowerSeriesRing(self._R,
                                       num_gens=2,
                                       default_prec=self._depth,
                                       names='X,Y')

        self._Sigma0Squared = Sigma0Squared(self._p, self._Rmod, adjuster)
        self._act = Sigma0SquaredAction(self._Sigma0Squared,
                                        self,
                                        act_on_left=act_on_left)
        self.register_action(self._act)
        self._populate_coercion_lists_()

        ## Initialise dictionaries of indices to translate between pairs and index for moments
        self._index = dict()
        self._ij = []
        m = 0

        ## Populate dictionary/array giving index of the basis element corr. to tuple (i,j), 0 <= i,j <= depth = n
        ## These things are ordered by degree of y, then degree of x: [1, x, x^2, ..., y, xy, ... ]
        for j in range(depth):
            for i in range(depth):
                self._ij.append((i, j))
                self._index[(i, j)] = m
                m += 1

        self._dimension = m  ## Number of moments we store

        ## Power series ring Zp[[x,y]]. We have to work with monomials up to x^depth * y^depth, so need prec = 2*depth
        self._PowerSeries_x = PowerSeriesRing(self._Rmod,
                                              default_prec=self._depth,
                                              names='x')
        self._PowerSeries_x_ZZ = PowerSeriesRing(ZZ,
                                                 default_prec=self._depth,
                                                 names='x')
        self._PowerSeries = PowerSeriesRing(self._PowerSeries_x,
                                            default_prec=self._depth,
                                            names='y')
        self._PowerSeries_ZZ = PowerSeriesRing(self._PowerSeries_x_ZZ,
                                               default_prec=self._depth,
                                               names='y')
Пример #2
0
 def create_key(self, k, p=None, prec_cap=None, base=None, \
                  character=None, adjuster=None, act_on_left=False, \
                  dettwist=None):
     k = ZZ(k)
     if base is None:
         if p is None:
             raise ValueError("Must specify a prime or a base ring.")
         if prec_cap is None:
             base = ZpCA(p)
         else:
             base = ZpCA(p, prec_cap)
     if prec_cap is None:
         prec_cap = base.precision_cap()
     elif prec_cap > base.precision_cap():
         raise ValueError("Insufficient precision in base ring (%s < %s)."%(base.precision_cap(), prec_cap))
     if p is None:
         p = base.prime()
     elif p != base.prime():
         raise ValueError("Prime p(=%s) must equal the prime of the base ring(=%s)"%(p, base.prime()))
     if adjuster is None:
         adjuster = _default_adjuster()
     if dettwist is not None:
         dettwist = ZZ(dettwist)
         if dettwist == 0: 
             dettwist = None
     return (k, p, prec_cap, base, character, adjuster, act_on_left, dettwist)
Пример #3
0
 def create_key(self, k, p=None, prec_cap=None, base=None, \
                  character=None, adjuster=None, act_on_left=False, \
                  dettwist=None):
     k = ZZ(k)
     if base is None:
         if p is None:
             raise ValueError("Must specify a prime or a base ring.")
         if prec_cap is None:
             base = ZpCA(p)
         else:
             base = ZpCA(p, prec_cap)
     if prec_cap is None:
         prec_cap = base.precision_cap()
     elif prec_cap > base.precision_cap():
         raise ValueError("Insufficient precision in base ring (%s < %s)." %
                          (base.precision_cap(), prec_cap))
     if p is None:
         p = base.prime()
     elif p != base.prime():
         raise ValueError(
             "Prime p(=%s) must equal the prime of the base ring(=%s)" %
             (p, base.prime()))
     if adjuster is None:
         adjuster = _default_adjuster()
     if dettwist is not None:
         dettwist = ZZ(dettwist)
         if dettwist == 0:
             dettwist = None
     return (k, p, prec_cap, base, character, adjuster, act_on_left,
             dettwist)
Пример #4
0
 def create_key(self, k, p=None, prec_cap=None, base=None, base_coeffs=None, \
                  character=None, adjuster=None, act_on_left=False, \
                  dettwist=None, variable_name = 'w'):
     if base is None:
         if base_coeffs is None:
             if p is None:
                 raise ValueError("Must specify a prime, a base ring, or coefficients.")
             if prec_cap is None:
                 raise ValueError("Must specify a precision cap or a base ring.")
             prec_cap = _prec_cap_parser(prec_cap)
             base_coeffs = Zp(p, prec = prec_cap[0])
         elif not isinstance(base_coeffs, ring.Ring):
             raise TypeError("base_coeffs must be a ring if base is None")
         elif prec_cap is None:
             raise ValueError("Must specify a precision cap or a base ring.")
         else:
             prec_cap = _prec_cap_parser(prec_cap)
             if base_coeffs.precision_cap() < prec_cap[0]:
                 raise ValueError("Precision cap on coefficients of base ring must be at least the p-adic precision cap of this space.")
         base = PowerSeriesRing(base_coeffs, name=variable_name, default_prec=prec_cap[1])
     elif prec_cap is None:
         prec_cap = [ZZ(base.base_ring().precision_cap()), ZZ(base.default_prec())]
     else:
         if base.base_ring().precision_cap() < prec_cap[0]:
             raise ValueError("Precision cap on coefficients of base ring must be at least the p-adic precision cap of this space.")
         if base.default_prec() < prec_cap[1]:
             raise ValueError("Default precision on the variable of base ring must be at least the w-adic precision cap of this space.")
     base_coeffs = None
     p = base.base_ring().prime()
     k_shift = 0
     #if character is not None:
     #    #Should we ensure character is primitive?
     #    cond_val = character.conductor().valuation(p)
     #    if cond_val > 1:
     #        raise ValueError("Level must not be divisible by p^2.")
     #    elif cond_val == 1:
     #        pass
     #    else:
     #        pass
     k = ZZ((k + k_shift) % (p-1))
     #if prec_cap is None:
     #    prec_cap = [base.base_ring().precision_cap, base.default_prec()]
     #else:
     #    prec_cap = list(prec_cap)
     #prec_cap = [base.base_ring().precision_cap(), base.default_prec()]
     if adjuster is None:
         adjuster = _default_adjuster()
     if dettwist is not None:
         dettwist = ZZ(dettwist)
         if dettwist == 0: 
             dettwist = None
     return (k, p, tuple(prec_cap), base, character, adjuster, act_on_left, dettwist)
Пример #5
0
    def create_key(self, k, base=None, character=None, adjuster=None, act_on_left=False, dettwist=None):
        r"""
        Sanitize input.

        EXAMPLE::

            sage: from sage.modular.pollack_stevens.distributions import Symk
            sage: Symk(6) # indirect doctest
            Sym^6 Q^2

            sage: V = Symk(6, Qp(7))
            sage: TestSuite(V).run()
        """
        k = ZZ(k)
        if adjuster is None:
            adjuster = _default_adjuster()
        prec_cap = k+1
        if base is None:
            base = QQ
        return (k, base, character, adjuster, act_on_left, dettwist)
Пример #6
0
    def create_key(self, k, p=None, prec_cap=None, base=None, character=None, adjuster=None, act_on_left=False, dettwist=None):
        """
        EXAMPLES::

            sage: from sage.modular.pollack_stevens.distributions import Distributions
            sage: Distributions(20, 3, 10)              # indirect doctest
            Space of 3-adic distributions with k=20 action and precision cap 10
            sage: TestSuite(Distributions).run()
        """
        k = ZZ(k)

        if p is None:
            try:
                p = base.prime()
            except AttributeError:
                raise ValueError("You must specify a prime")
        else:
            p = ZZ(p)
        
        if base is None:
            if prec_cap is None:
                base = ZpCA(p)
            else:
                base = ZpCA(p, prec_cap)
        
        if prec_cap is None:
            try:
                prec_cap = base.precision_cap()
            except AttributeError:
                raise ValueError("You must specify a base or precision cap")

        if adjuster is None:
            adjuster = _default_adjuster()

        if dettwist is not None:
            dettwist = ZZ(dettwist)
            if dettwist == 0: 
                dettwist = None

        return (k, p, prec_cap, base, character, adjuster, act_on_left, dettwist)