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 integral domains
sage: TestSuite(RZZ).run()
sage: R1 = LaurentSeriesRing(Zmod(1), 't')
sage: R1.category()
Category of finite commutative rings
sage: TestSuite(R1).run()
sage: R2 = LaurentSeriesRing(Zmod(2), 't')
sage: R2.category()
Category of infinite complete discrete valuation fields
sage: TestSuite(R2).run()
sage: R4 = LaurentSeriesRing(Zmod(4), 't')
sage: R4.category()
Category of infinite commutative rings
sage: TestSuite(R4).run()
sage: RQQ = LaurentSeriesRing(QQ, 't')
sage: RQQ.category()
Category of infinite complete discrete valuation fields
sage: TestSuite(RQQ).run()
"""
base_ring = power_series.base_ring()
if base_ring in Fields():
category = CompleteDiscreteValuationFields()
elif base_ring in IntegralDomains():
category = IntegralDomains()
elif base_ring in Rings().Commutative():
category = Rings().Commutative()
else:
raise ValueError('unrecognized base ring')
if base_ring.is_zero():
category = category.Finite()
else:
category = category.Infinite()
CommutativeRing.__init__(self,
base_ring,
names=power_series.variable_names(),
category=category)
self._power_series_ring = power_series
def __init__(self, base):
if base not in IntegralDomains():
raise ValueError("%s is no integral domain" % base);
IntegralDomain.__init__(self, base, category=IntegralDomains());
self._zero_element = SimpleLIDElement(self, base.zero());
self._one_element = SimpleLIDElement(self, base.one());
self.base().register_conversion(LIDSimpleMorphism(self, self.base()));
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)
def fraction_field(self):
r"""
Return the fraction field of this ring of Laurent series.
If the base ring is a field, then Laurent series are already a field.
If the base ring is a domain, then the Laurent series over its fraction
field is returned. Otherwise, raise a ``ValueError``.
EXAMPLES::
sage: R = LaurentSeriesRing(ZZ, 't', 30).fraction_field()
sage: R
Laurent Series Ring in t over Rational Field
sage: R.default_prec()
30
sage: LaurentSeriesRing(Zmod(4), 't').fraction_field()
Traceback (most recent call last):
...
ValueError: must be an integral domain
"""
from sage.categories.integral_domains import IntegralDomains
from sage.categories.fields import Fields
if self in Fields():
return self
elif self in IntegralDomains():
return LaurentSeriesRing(self.base_ring().fraction_field(),
self.variable_names(),
self.default_prec())
else:
raise ValueError('must be an integral domain')
def super_categories(self):
"""
EXAMPLES::
sage: GcdDomains().super_categories()
[Category of integral domains]
"""
return [IntegralDomains()]
def super_categories(self):
"""
EXAMPLES::
sage: GcdDomains().super_categories()
[Category of integral domains]
"""
from sage.categories.integral_domains import IntegralDomains
return [IntegralDomains()]
def __hash__(self):
"""
Compute the hash value of this point.
If the base ring has a fraction field, normalize the point in
the fraction field and then hash so that equal points have
equal hash values. If the base ring is not an integral domain,
return the hash of the parent.
OUTPUT: Integer.
EXAMPLES::
sage: P.<x,y> = ProjectiveSpace(ZZ, 1)
sage: hash(P([1, 1]))
1300952125 # 32-bit
3713081631935493181 # 64-bit
sage: hash(P.point([2, 2], False))
1300952125 # 32-bit
3713081631935493181 # 64-bit
::
sage: R.<x> = PolynomialRing(QQ)
sage: K.<w> = NumberField(x^2 + 3)
sage: O = K.maximal_order()
sage: P.<x,y> = ProjectiveSpace(O, 1)
sage: hash(P([1+w, 2]))
-1562365407 # 32-bit
1251212645657227809 # 64-bit
sage: hash(P([2, 1-w]))
-1562365407 # 32-bit
1251212645657227809 # 64-bit
TESTS::
sage: P.<x,y> = ProjectiveSpace(Zmod(10), 1)
sage: Q.<x,y> = ProjectiveSpace(Zmod(10), 1)
sage: hash(P([2, 5])) == hash(Q([2, 5]))
True
sage: hash(P([2, 5])) == hash(P([2,5]))
True
sage: hash(P([3, 7])) == hash(P([2,5]))
True
"""
R = self.codomain().base_ring()
#if there is a fraction field normalize the point so that
#equal points have equal hash values
if R in IntegralDomains():
P = self.change_ring(FractionField(R))
P.normalize_coordinates()
return hash(tuple(P))
#if there is no good way to normalize return
#a constant value
return hash(self.codomain())
def _convert_map_from_(self, R):
"""
Finds conversion maps from R to this ring.
Currently, a conversion exists if the defining polynomial is the same.
EXAMPLES::
sage: R.<a> = Zq(125)
sage: S = R.change(type='capped-abs', prec=40, print_mode='terse', print_pos=False)
sage: S(a - 15)
-15 + a + O(5^20)
We get conversions from the exact field::
sage: K = R.exact_field(); K
Number Field in a with defining polynomial x^3 + 3*x + 3
sage: R(K.gen())
a + O(5^20)
and its maximal order::
sage: OK = K.maximal_order()
sage: R(OK.gen(1))
a + O(5^20)
"""
cat = None
if self._implementation == 'NTL' and R == QQ:
# Want to use DefaultConvertMap_unique
return None
if isinstance(R, pAdicExtensionGeneric) and R.prime() == self.prime(
) and R.defining_polynomial(exact=True) == self.defining_polynomial(
exact=True):
if R.is_field() and not self.is_field():
cat = SetsWithPartialMaps()
elif R.category() is self.category():
cat = R.category()
else:
cat = EuclideanDomains() & MetricSpaces().Complete()
elif isinstance(R, Order) and R.number_field().defining_polynomial(
) == self.defining_polynomial():
cat = IntegralDomains()
elif isinstance(R, NumberField) and R.defining_polynomial(
) == self.defining_polynomial():
if self.is_field():
cat = Fields()
else:
cat = SetsWithPartialMaps()
else:
k = self.residue_field()
if R is k:
return ResidueLiftingMap._create_(R, self)
if cat is not None:
H = Hom(R, self, cat)
return H.__make_element_class__(DefPolyConversion)(H)
def __init__(self,
base_ring,
additional_units,
names=None,
normalize=True,
category=None,
warning=True):
"""
Python constructor of Localization.
TESTS::
sage: L = Localization(ZZ, (3,5))
sage: TestSuite(L).run()
sage: R.<x> = ZZ[]
sage: L = R.localization(x**2+1)
sage: TestSuite(L).run()
"""
if type(additional_units) is tuple:
additional_units = list(additional_units)
if not type(additional_units) is list:
additional_units = [additional_units]
if isinstance(base_ring, Localization):
# don't allow recursive constructions
additional_units += base_ring._additional_units
base_ring = base_ring.base_ring()
additional_units = normalize_additional_units(base_ring,
additional_units,
warning=warning)
if not additional_units:
raise ValueError('all given elements are invertible in %s' %
(base_ring))
if category is None:
# since by construction the base ring must contain non units self must be infinite
category = IntegralDomains().Infinite()
IntegralDomain.__init__(self,
base_ring,
names=None,
normalize=True,
category=category)
self._additional_units = tuple(additional_units)
self._fraction_field = base_ring.fraction_field()
self._populate_coercion_lists_()
def __hash__(self):
"""
Computes the hash value of this point.
OUTPUT: Integer.
EXAMPLES::
sage: PP = ProductProjectiveSpaces(Zmod(6), [1, 1])
sage: hash(PP([5, 1, 2, 4]))
1266382469 # 32-bit
-855399699883264379 # 64-bit
::
sage: PP = ProductProjectiveSpaces(ZZ, [1, 2])
sage: hash(PP([1, 1, 2, 2, 2]))
805439612 # 32-bit
7267864846446758012 # 64-bit
sage: hash(PP([1, 1, 1, 1, 1]))
805439612 # 32-bit
7267864846446758012 # 64-bit
::
sage: PP = ProductProjectiveSpaces(QQ, [1, 1])
sage: hash(PP([1/7, 1, 2, 1]))
1139616004 # 32-bit
-7585172175017137916 # 64-bit
::
sage: PP = ProductProjectiveSpaces(GF(7), [1, 1, 1])
sage: hash(PP([4, 1, 5, 4, 6, 1]))
1796924635 # 32-bit
-4539377540667874085 # 64-bit
"""
R = self.codomain().base_ring()
# if there is a fraction field normalize the point so that
# equal points have equal hash values
if R in IntegralDomains():
P = self.change_ring(FractionField(R))
P.normalize_coordinates()
return hash(tuple(P))
# if there is no good way to normalize return
# a constant value
return hash(self.codomain())
def __hash__(self):
"""
Compute the hash value of this point.
OUTPUT: Integer.
EXAMPLES::
sage: PP = ProductProjectiveSpaces(Zmod(6), [1, 1])
sage: H = hash(PP([5, 1, 2, 4]))
::
sage: PP = ProductProjectiveSpaces(ZZ, [1, 2])
sage: hash(PP([1, 1, 2, 2, 2])) == hash(PP([1, 1, 1, 1, 1]))
True
::
sage: PP = ProductProjectiveSpaces(QQ, [1, 1])
sage: hash(PP([1/7, 1, 2, 1])) == hash((1/7, 1, 2, 1))
True
::
sage: PP = ProductProjectiveSpaces(GF(7), [1, 1, 1])
sage: hash(PP([4, 1, 5, 4, 6, 1])) == hash((4, 1, 5, 4, 6, 1))
False
sage: hash(PP([4, 1, 5, 4, 6, 1])) == hash((4, 1, 3, 1, 6, 1))
True
"""
R = self.codomain().base_ring()
# if there is a fraction field normalize the point so that
# equal points have equal hash values
if R in IntegralDomains():
P = self.change_ring(FractionField(R))
P.normalize_coordinates()
return hash(tuple(P))
# if there is no good way to normalize return
# a constant value
return hash(self.codomain())
from sage.structure.element import is_Element
import sage.rings.ring as ring
import sage.rings.padics.padic_base_leaves as padic_base_leaves
from sage.rings.integer import Integer
from sage.rings.finite_rings.constructor import is_FiniteField
from sage.rings.finite_rings.integer_mod_ring import is_IntegerModRing
from sage.misc.cachefunc import weak_cached_function
from sage.categories.fields import Fields
_Fields = Fields()
from sage.categories.unique_factorization_domains import UniqueFactorizationDomains
_UFD = UniqueFactorizationDomains()
from sage.categories.integral_domains import IntegralDomains
_ID = IntegralDomains()
from sage.categories.commutative_rings import CommutativeRings
_CommutativeRings = CommutativeRings()
import weakref
_cache = weakref.WeakValueDictionary()
def PolynomialRing(base_ring,
arg1=None,
arg2=None,
sparse=False,
order='degrevlex',
names=None,
name=None,
var_array=None,
def __init__(self):
ID = IntegralDomains();
self.rank = 20 ;
super(LazyDDRingFunctor, self).__init__(ID,ID);
def is_injective(self):
"""
Return whether or not this morphism is injective.
EXAMPLES:
This often raises a ``NotImplementedError`` as many homomorphisms do
not implement this method::
sage: R.<x> = QQ[]
sage: f = R.hom([x + 1]); f
Ring endomorphism of Univariate Polynomial Ring in x over Rational Field
Defn: x |--> x + 1
sage: f.is_injective()
Traceback (most recent call last):
...
NotImplementedError
If the domain is a field, the homomorphism is injective::
sage: K.<x> = FunctionField(QQ)
sage: L.<y> = FunctionField(QQ)
sage: f = K.hom([y]); f
Function Field morphism:
From: Rational function field in x over Rational Field
To: Rational function field in y over Rational Field
Defn: x |--> y
sage: f.is_injective()
True
Unless the codomain is the zero ring::
sage: codomain = Integers(1)
sage: f = QQ.hom([Zmod(1)(0)], check=False)
sage: f.is_injective()
False
Homomorphism from rings of characteristic zero to rings of positive
characteristic can not be injective::
sage: R.<x> = ZZ[]
sage: f = R.hom([GF(3)(1)]); f
Ring morphism:
From: Univariate Polynomial Ring in x over Integer Ring
To: Finite Field of size 3
Defn: x |--> 1
sage: f.is_injective()
False
A morphism whose domain is an order in a number field is injective if
the codomain has characteristic zero::
sage: K.<x> = FunctionField(QQ)
sage: f = ZZ.hom(K); f
Composite map:
From: Integer Ring
To: Rational function field in x over Rational Field
Defn: Conversion via FractionFieldElement_1poly_field map:
From: Integer Ring
To: Fraction Field of Univariate Polynomial Ring in x over Rational Field
then
Isomorphism:
From: Fraction Field of Univariate Polynomial Ring in x over Rational Field
To: Rational function field in x over Rational Field
sage: f.is_injective()
True
A coercion to the fraction field is injective::
sage: R = ZpFM(3)
sage: R.fraction_field().coerce_map_from(R).is_injective()
True
"""
if self.domain().is_zero():
return True
if self.codomain().is_zero():
# the only map to the zero ring that is injective is the map from itself
return False
from sage.categories.fields import Fields
if self.domain() in Fields():
# A ring homomorphism from a field to a ring is injective
# (unless the codomain is the zero ring.) Note that ring
# homomorphism must send the 1 element to the 1 element
return True
if self.domain().characteristic() == 0:
if self.codomain().characteristic() != 0:
return False
else:
from sage.categories.integral_domains import IntegralDomains
if self.domain() in IntegralDomains():
# if all elements of the domain are algebraic over ZZ,
# then the homomorphism must be injective (in
# particular if the domain is ZZ)
from sage.categories.number_fields import NumberFields
if self.domain().fraction_field() in NumberFields():
return True
if self._is_coercion:
try:
K = self.domain().fraction_field()
except (TypeError, AttributeError, ValueError):
pass
else:
if K is self.codomain():
return True
if self.domain().cardinality() > self.codomain().cardinality():
return False
raise NotImplementedError
from sage.rings.commutative_ring import is_CommutativeRing, CommutativeRing
from sage.rings.polynomial.all import PolynomialRing, is_MPolynomialRing, is_PolynomialRing
from sage.rings.polynomial.term_order import TermOrder
from sage.rings.power_series_ring import PowerSeriesRing, PowerSeriesRing_generic, is_PowerSeriesRing
from sage.rings.infinity import infinity
import sage.misc.latex as latex
from sage.structure.nonexact import Nonexact
from sage.rings.multi_power_series_ring_element import MPowerSeries
from sage.categories.commutative_rings import CommutativeRings
_CommutativeRings = CommutativeRings()
from sage.categories.integral_domains import IntegralDomains
_IntegralDomains = IntegralDomains()
def is_MPowerSeriesRing(x):
"""
Return true if input is a multivariate power series ring.
TESTS::
sage: from sage.rings.power_series_ring import is_PowerSeriesRing
sage: from sage.rings.multi_power_series_ring import is_MPowerSeriesRing
sage: M = PowerSeriesRing(ZZ,4,'v');
sage: is_PowerSeriesRing(M)
False
sage: is_MPowerSeriesRing(M)
True
def __init__(self):
ID = IntegralDomains();
self.rank = _sage_const_20 ;
super(LazyIntegralDomainFunctor, self).__init__(ID,ID);