def polynomial_default_category(base_ring, multivariate):
"""
Choose an appropriate category for a polynomial ring.
INPUT:
- ``base_ring``: The ring over which the polynomial ring shall be defined.
- ``multivariate``: Will the polynomial ring be multivariate?
EXAMPLES::
sage: QQ['t'].category() is Category.join([EuclideanDomains(), CommutativeAlgebras(QQ)])
True
sage: QQ['s','t'].category() is Category.join([UniqueFactorizationDomains(), CommutativeAlgebras(QQ)])
True
sage: QQ['s']['t'].category() is Category.join([UniqueFactorizationDomains(), CommutativeAlgebras(QQ['s'])])
True
"""
if base_ring in _Fields:
if multivariate:
return JoinCategory(
(_UniqueFactorizationDomains, CommutativeAlgebras(base_ring)))
return JoinCategory(
(_EuclideanDomains, CommutativeAlgebras(base_ring)))
if base_ring in _UFD: #base_ring.is_unique_factorization_domain():
return JoinCategory(
(_UniqueFactorizationDomains, CommutativeAlgebras(base_ring)))
if base_ring in _ID: #base_ring.is_integral_domain():
return JoinCategory((_IntegralDomains, CommutativeAlgebras(base_ring)))
if base_ring in _CommutativeRings: #base_ring.is_commutative():
return CommutativeAlgebras(base_ring)
return Algebras(base_ring)
def __init__(self, R, names):
r"""
Initialize ``self``.
EXAMPLES::
sage: F = ShuffleAlgebra(QQ, 'xyz'); F
Shuffle Algebra on 3 generators ['x', 'y', 'z'] over Rational Field
sage: TestSuite(F).run()
TESTS::
sage: ShuffleAlgebra(24, 'toto')
Traceback (most recent call last):
...
TypeError: argument R must be a ring
"""
if R not in Rings():
raise TypeError("argument R must be a ring")
self._alphabet = names
self.__ngens = self._alphabet.cardinality()
CombinatorialFreeModule.__init__(self,
R,
Words(names, infinite=False),
latex_prefix="",
category=(AlgebrasWithBasis(R),
CommutativeAlgebras(R),
CoalgebrasWithBasis(R)))
def __init__(self, domain):
r"""
Construct an algebra of scalar fields.
TESTS::
sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: CM = M.scalar_field_algebra(); CM
Algebra of scalar fields on the 2-dimensional topological
manifold M
sage: type(CM)
<class 'sage.manifolds.scalarfield_algebra.ScalarFieldAlgebra_with_category'>
sage: type(CM).__base__
<class 'sage.manifolds.scalarfield_algebra.ScalarFieldAlgebra'>
sage: TestSuite(CM).run()
"""
base_field = domain.base_field()
if domain.base_field_type() in ['real', 'complex']:
base_field = SR
Parent.__init__(self, base=base_field,
category=CommutativeAlgebras(base_field))
self._domain = domain
self._populate_coercion_lists_()
def __init__(self, A):
"""
EXAMPLES::
sage: AlgebraModules(QQ['a'])
Category of algebra modules over Univariate Polynomial Ring in a over Rational Field
sage: AlgebraModules(QQ['a,b']) # todo: not implemented (QQ['a,b'] should be in Algebras(QQ))
sage: AlgebraModules(FreeAlgebra(QQ,2,'a,b'))
Traceback (most recent call last):
...
TypeError: A (=Free Algebra on 2 generators (a, b) over Rational Field) must be a commutative algebra
sage: AlgebraModules(QQ)
Traceback (most recent call last):
...
TypeError: A (=Rational Field) must be a commutative algebra
TESTS::
sage: TestSuite(AlgebraModules(QQ['a'])).run()
"""
from sage.categories.commutative_algebras import CommutativeAlgebras
if not hasattr(A, "base_ring") or A not in CommutativeAlgebras(
A.base_ring()):
raise TypeError("A (=%s) must be a commutative algebra" % A)
Category_module.__init__(self, A)
def __init__(self, field, prec, log_radii, names, order, integral=False):
"""
Initialize the Tate algebra
TESTS::
sage: A.<x,y> = TateAlgebra(Zp(2), log_radii=1)
sage: TestSuite(A).run()
We check that univariate Tate algebras work correctly::
sage: B.<t> = TateAlgebra(Zp(3))
"""
from sage.misc.latex import latex_variable_name
from sage.rings.polynomial.polynomial_ring_constructor import _multi_variate
self.element_class = TateAlgebraElement
self._field = field
self._cap = prec
self._log_radii = ETuple(log_radii) # TODO: allow log_radii in QQ
self._names = names
self._latex_names = [latex_variable_name(var) for var in names]
uniformizer = field.change(print_mode='terse',
show_prec=False).uniformizer()
self._uniformizer_repr = uniformizer._repr_()
self._uniformizer_latex = uniformizer._latex_()
self._ngens = len(names)
self._order = order
self._integral = integral
if integral:
base = field.integer_ring()
else:
base = field
CommutativeAlgebra.__init__(self,
base,
names,
category=CommutativeAlgebras(base))
self._polynomial_ring = _multi_variate(field, names, order=order)
one = field(1)
self._parent_terms = TateTermMonoid(self)
self._oneterm = self._parent_terms(one, ETuple([0] * self._ngens))
if integral:
# This needs to be update if log_radii are allowed to be non-integral
self._gens = [
self((one << log_radii[i]) * self._polynomial_ring.gen(i))
for i in range(self._ngens)
]
self._integer_ring = self
else:
self._gens = [self(g) for g in self._polynomial_ring.gens()]
self._integer_ring = TateAlgebra_generic(field,
prec,
log_radii,
names,
order,
integral=True)
self._integer_ring._rational_ring = self._rational_ring = self
def __init__(self, R, names):
"""
Initialize ``self``.
EXAMPLES::
sage: D = ShuffleAlgebra(QQ, 'ab').dual_pbw_basis()
sage: TestSuite(D).run()
"""
self._alphabet = names
self._alg = ShuffleAlgebra(R, names)
CombinatorialFreeModule.__init__(self, R, Words(names), prefix='S',
category=(AlgebrasWithBasis(R), CommutativeAlgebras(R), CoalgebrasWithBasis(R)))
def __init__(self, domain):
Parent.__init__(self, base=SR, category=CommutativeAlgebras(SR))
self._domain = domain
self._populate_coercion_lists_()
self._zero = None # zero element (not constructed yet)
