def polynomial_default_category(base_ring_category, n_variables):
"""
Choose an appropriate category for a polynomial ring.
It is assumed that the corresponding base ring is nonzero.
INPUT:
- ``base_ring_category`` -- The category of ring over which the polynomial
ring shall be defined
- ``n_variables`` -- number of variables
EXAMPLES::
sage: from sage.rings.polynomial.polynomial_ring_constructor import polynomial_default_category
sage: polynomial_default_category(Rings(),1) is Algebras(Rings()).Infinite()
True
sage: polynomial_default_category(Rings().Commutative(),1) is Algebras(Rings().Commutative()).Commutative().Infinite()
True
sage: polynomial_default_category(Fields(),1) is EuclideanDomains() & Algebras(Fields()).Infinite()
True
sage: polynomial_default_category(Fields(),2) is UniqueFactorizationDomains() & CommutativeAlgebras(Fields()).Infinite()
True
sage: QQ['t'].category() is EuclideanDomains() & CommutativeAlgebras(QQ.category()).Infinite()
True
sage: QQ['s','t'].category() is UniqueFactorizationDomains() & CommutativeAlgebras(QQ.category()).Infinite()
True
sage: QQ['s']['t'].category() is UniqueFactorizationDomains() & CommutativeAlgebras(QQ['s'].category()).Infinite()
True
"""
category = Algebras(base_ring_category)
if n_variables:
# here we assume the base ring to be nonzero
category = category.Infinite()
else:
if base_ring_category.is_subcategory(_Fields):
category = category & _Fields
if base_ring_category.is_subcategory(_FiniteSets):
category = category.Finite()
elif base_ring_category.is_subcategory(_InfiniteSets):
category = category.Infinite()
if base_ring_category.is_subcategory(_Fields) and n_variables == 1:
return category & _EuclideanDomains
elif base_ring_category.is_subcategory(_UniqueFactorizationDomains):
return category & _UniqueFactorizationDomains
elif base_ring_category.is_subcategory(_IntegralDomains):
return category & _IntegralDomains
elif base_ring_category.is_subcategory(_CommutativeRings):
return category & _CommutativeRings
return category
def __init__(self, base_ring, names, sparse=True, category=None):
"""
Initialize the ring.
TESTS::
sage: L = LazyDirichletSeriesRing(ZZ, 't')
sage: TestSuite(L).run(skip=['_test_elements', '_test_associativity', '_test_distributivity', '_test_zero'])
"""
if base_ring.characteristic() > 0:
raise ValueError("positive characteristic not allowed for Dirichlet series")
self._sparse = sparse
self._coeff_ring = base_ring
# TODO: it would be good to have something better than the symbolic ring
self._laurent_poly_ring = SR
self._internal_poly_ring = PolynomialRing(base_ring, names, sparse=True)
category = Algebras(base_ring.category())
if base_ring in IntegralDomains():
category &= IntegralDomains()
elif base_ring in Rings().Commutative():
category = category.Commutative()
category = category.Infinite()
Parent.__init__(self, base=base_ring, names=names,
category=category)
def __init__(self, power_series):
"""
Initialization
EXAMPLES::
sage: K.<q> = LaurentSeriesRing(QQ, default_prec=4); K
Laurent Series Ring in q over Rational Field
sage: 1 / (q-q^2)
q^-1 + 1 + q + q^2 + O(q^3)
sage: RZZ = LaurentSeriesRing(ZZ, 't')
sage: RZZ.category()
Category of infinite commutative no zero divisors algebras over (euclidean domains and infinite enumerated sets and metric spaces)
sage: TestSuite(RZZ).run()
sage: R1 = LaurentSeriesRing(Zmod(1), 't')
sage: R1.category()
Category of finite commutative algebras over (finite commutative rings and subquotients of monoids and quotients of semigroups and finite enumerated sets)
sage: TestSuite(R1).run()
sage: R2 = LaurentSeriesRing(Zmod(2), 't')
sage: R2.category()
Join of Category of complete discrete valuation fields and Category of commutative algebras over (finite enumerated fields and subquotients of monoids and quotients of semigroups) and Category of infinite sets
sage: TestSuite(R2).run()
sage: R4 = LaurentSeriesRing(Zmod(4), 't')
sage: R4.category()
Category of infinite commutative algebras over (finite commutative rings and subquotients of monoids and quotients of semigroups and finite enumerated sets)
sage: TestSuite(R4).run()
sage: RQQ = LaurentSeriesRing(QQ, 't')
sage: RQQ.category()
Join of Category of complete discrete valuation fields and Category of commutative algebras over (number fields and quotient fields and metric spaces) and Category of infinite sets
sage: TestSuite(RQQ).run()
"""
base_ring = power_series.base_ring()
category = Algebras(base_ring.category())
if base_ring in Fields():
category &= CompleteDiscreteValuationFields()
elif base_ring in IntegralDomains():
category &= IntegralDomains()
elif base_ring in Rings().Commutative():
category = category.Commutative()
if base_ring.is_zero():
category = category.Finite()
else:
category = category.Infinite()
self._power_series_ring = power_series
self._one_element = self.element_class(self, power_series.one())
CommutativeRing.__init__(self,
base_ring,
names=power_series.variable_names(),
category=category)
def __init__(self, base_ring, names, sparse=True, category=None):
"""
Initialize ``self``.
TESTS::
sage: L = LazyLaurentSeriesRing(ZZ, 't')
sage: elts = L.some_elements()[:-2] # skip the non-exact elements
sage: TestSuite(L).run(elements=elts, skip=['_test_elements', '_test_associativity', '_test_distributivity', '_test_zero'])
sage: L.category()
Category of infinite commutative no zero divisors algebras over
(euclidean domains and infinite enumerated sets and metric spaces)
sage: L = LazyLaurentSeriesRing(QQ, 't')
sage: L.category()
Join of Category of complete discrete valuation fields
and Category of commutative algebras over (number fields and quotient fields and metric spaces)
and Category of infinite sets
sage: L = LazyLaurentSeriesRing(ZZ['x,y'], 't')
sage: L.category()
Category of infinite commutative no zero divisors algebras over
(unique factorization domains and commutative algebras over
(euclidean domains and infinite enumerated sets and metric spaces)
and infinite sets)
sage: E.<x,y> = ExteriorAlgebra(QQ)
sage: L = LazyLaurentSeriesRing(E, 't') # not tested
"""
self._sparse = sparse
self._coeff_ring = base_ring
# We always use the dense because our CS_exact is implemented densely
self._laurent_poly_ring = LaurentPolynomialRing(base_ring, names)
self._internal_poly_ring = self._laurent_poly_ring
category = Algebras(base_ring.category())
if base_ring in Fields():
category &= CompleteDiscreteValuationFields()
else:
if "Commutative" in base_ring.category().axioms():
category = category.Commutative()
if base_ring in IntegralDomains():
category &= IntegralDomains()
if base_ring.is_zero():
category = category.Finite()
else:
category = category.Infinite()
Parent.__init__(self, base=base_ring, names=names, category=category)
