def __init__(self, laurent_series):
"""
Generic class for Puiseux series rings.
EXAMPLES::
sage: P = PuiseuxSeriesRing(QQ, 'y')
sage: TestSuite(P).run()
sage: P = PuiseuxSeriesRing(ZZ, 'x')
sage: TestSuite(P).run()
sage: P = PuiseuxSeriesRing(ZZ['a,b'], 'x')
sage: TestSuite(P).run()
"""
base_ring = laurent_series.base_ring()
# If self is R(( x^(1/e) )) then the corresponding Laurent series
# ring will be R(( x ))
self._laurent_series_ring = laurent_series
CommutativeRing.__init__(self,
base_ring,
names=laurent_series.variable_names(),
category=laurent_series.category())
def __init__(self, polynomial_ring, category):
r"""
Create the ring of CFiniteSequences over ``base_ring``
INPUT:
- ``base_ring`` -- the base ring for the o.g.f (either ``QQ`` or ``ZZ``)
- ``names`` -- an iterable of variables (should contain only one variable)
- ``category`` -- the category of the ring (default: ``Fields()``)
TESTS::
sage: C.<y> = CFiniteSequences(QQ); C
The ring of C-Finite sequences in y over Rational Field
sage: C.<x> = CFiniteSequences(QQ); C
The ring of C-Finite sequences in x over Rational Field
sage: C.<x> = CFiniteSequences(ZZ); C
The ring of C-Finite sequences in x over Integer Ring
sage: C.<x,y> = CFiniteSequences(ZZ)
Traceback (most recent call last):
...
NotImplementedError: Multidimensional o.g.f. not implemented.
sage: C.<x> = CFiniteSequences(CC)
Traceback (most recent call last):
...
ValueError: O.g.f. base not rational.
"""
base_ring = polynomial_ring.base_ring()
self._polynomial_ring = polynomial_ring
self._fraction_field = FractionField(self._polynomial_ring)
CommutativeRing.__init__(self, base_ring, self._polynomial_ring.gens(),
category)
def __init__(self, polynomial_ring, category):
r"""
Create the ring of CFiniteSequences over ``base_ring``
INPUT:
- ``base_ring`` -- the base ring for the o.g.f (either ``QQ`` or ``ZZ``)
- ``names`` -- an iterable of variables (shuould contain only one variable)
- ``category`` -- the category of the ring (default: ``Fields()``)
TESTS::
sage: C.<y> = CFiniteSequences(QQ); C
The ring of C-Finite sequences in y over Rational Field
sage: C.<x> = CFiniteSequences(QQ); C
The ring of C-Finite sequences in x over Rational Field
sage: C.<x> = CFiniteSequences(ZZ); C
The ring of C-Finite sequences in x over Integer Ring
sage: C.<x,y> = CFiniteSequences(ZZ)
Traceback (most recent call last):
...
NotImplementedError: Multidimensional o.g.f. not implemented.
sage: C.<x> = CFiniteSequences(CC)
Traceback (most recent call last):
...
ValueError: O.g.f. base not rational.
"""
base_ring = polynomial_ring.base_ring()
self._polynomial_ring = polynomial_ring
self._fraction_field = FractionField(self._polynomial_ring)
CommutativeRing.__init__(self,base_ring, self._polynomial_ring.gens(), category)
def __init__(self, p):
if not p.is_prime():
raise ValueError("p must be a prime number")
self._p = p
CommutativeRing.__init__(self, self)
from lazy import LazyApproximation_padics
self._lazy_class = LazyApproximation_padics
self._zero = self(0)
self._lazy_zero = self._lazy_class(self, self._zero)
self._lazy_zero._length = 0
def __init__(self, R):
"""
EXAMPLES::
sage: R = LaurentPolynomialRing(QQ,2,'x')
sage: R == loads(dumps(R))
True
"""
self._n = R.ngens()
self._R = R
names = R.variable_names()
CommutativeRing.__init__(self, R.base_ring(), names=names)
self._populate_coercion_lists_(init_no_parent=True)
def __init__(self, R, prepend_string, names):
"""
EXAMPLES::
sage: R = LaurentPolynomialRing(QQ,2,'x')
sage: R == loads(dumps(R))
True
"""
self._n = R.ngens()
self._R = R
self._prepend_string = prepend_string
CommutativeRing.__init__(self, R.base_ring(), names=names)
self._populate_coercion_lists_(element_constructor=self._element_constructor_,
init_no_parent=True)
def __init__(self, R):
"""
EXAMPLES::
sage: R = LaurentPolynomialRing(QQ,2,'x')
sage: R == loads(dumps(R))
True
"""
self._n = R.ngens()
self._R = R
names = R.variable_names()
self._one_element = self.element_class(self, R.one())
CommutativeRing.__init__(self, R.base_ring(), names=names,
category=R.category())
def __init__(self, R, prepend_string, names):
"""
EXAMPLES::
sage: R = LaurentPolynomialRing(QQ,2,'x')
sage: R == loads(dumps(R))
True
"""
self._n = R.ngens()
self._R = R
self._prepend_string = prepend_string
CommutativeRing.__init__(self, R.base_ring(), names=names)
self._populate_coercion_lists_(
element_constructor=self._element_constructor_,
init_no_parent=True)
def extension(self, poly, name=None, names=None, embedding=None):
if self.modulus() == 1:
return self
else:
from sage.rings.ring import CommutativeRing
return CommutativeRing.extension(self, poly, name, names,
embedding)
def extension(self, poly, name=None, names=None, embedding=None):
"""
Return an algebraic extension of ``self``. See
:meth:`sage.rings.ring.CommutativeRing.extension()` for more
information.
EXAMPLES::
sage: R.<t> = QQ[]
sage: Integers(8).extension(t^2 - 3)
Univariate Quotient Polynomial Ring in t over Ring of integers modulo 8 with modulus t^2 + 5
"""
if self.modulus() == 1:
return self
from sage.rings.ring import CommutativeRing
return CommutativeRing.extension(self, poly, name, names, embedding)
def extension(self, poly, name=None, names=None, embedding=None):
"""
Return an algebraic extension of ``self``. See
:meth:`sage.rings.ring.CommutativeRing.extension()` for more
information.
EXAMPLES::
sage: R.<t> = QQ[]
sage: Integers(8).extension(t^2 - 3)
Univariate Quotient Polynomial Ring in t over Ring of integers modulo 8 with modulus t^2 + 5
"""
if self.modulus() == 1:
return self
from sage.rings.ring import CommutativeRing
return CommutativeRing.extension(self, poly, name, names, embedding)
def __init__(self,
base_ring,
num_gens,
name_list,
order='negdeglex',
default_prec=10,
sparse=False):
"""
Initializes a multivariate power series ring. See PowerSeriesRing
for complete documentation.
INPUT:
- ``base_ring`` -- a commutative ring
- ``num_gens`` -- number of generators
- ``name_list`` -- List of indeterminate names or a single name.
If a single name is given, indeterminates will be this name
followed by a number from 0 to num_gens - 1. If a list is
given, these will be the indeterminate names and the length
of the list must be equal to num_gens.
- ``order`` -- ordering of variables; default is
negative degree lexicographic
- ``default_prec`` -- The default total-degree precision for
elements. The default value of default_prec is 10.
- ``sparse`` -- whether or not the power series are sparse.
The underlying polynomial ring is always sparse.
EXAMPLES::
sage: R.<t,u,v> = PowerSeriesRing(QQ)
sage: g = 1 + v + 3*u*t^2 - 2*v^2*t^2
sage: g = g.add_bigoh(5); g
1 + v + 3*t^2*u - 2*t^2*v^2 + O(t, u, v)^5
sage: g in R
True
TESTS:
By :trac:`14084`, the multi-variate power series ring belongs to the
category of integral domains, if the base ring does::
sage: P = ZZ[['x','y']]
sage: P.category()
Category of integral domains
sage: TestSuite(P).run()
Otherwise, it belongs to the category of commutative rings::
sage: P = Integers(15)[['x','y']]
sage: P.category()
Category of commutative rings
sage: TestSuite(P).run()
"""
order = TermOrder(order, num_gens)
self._term_order = order
if not base_ring.is_commutative():
raise TypeError("Base ring must be a commutative ring.")
n = int(num_gens)
if n < 0:
raise ValueError(
"Multivariate Polynomial Rings must have more than 0 variables."
)
self._ngens = n
self._has_singular = False #cannot convert to Singular by default
# Multivariate power series rings inherit from power series rings. But
# apparently we can not call their initialisation. Instead, initialise
# CommutativeRing and Nonexact:
CommutativeRing.__init__(self,
base_ring,
name_list,
category=_IntegralDomains if base_ring
in _IntegralDomains else _CommutativeRings)
Nonexact.__init__(self, default_prec)
# underlying polynomial ring in which to represent elements
self._poly_ring_ = PolynomialRing(base_ring,
self.variable_names(),
order=order)
# because sometimes PowerSeriesRing_generic calls self.__poly_ring
self._PowerSeriesRing_generic__poly_ring = self._poly_ring()
# background univariate power series ring
self._bg_power_series_ring = PowerSeriesRing(self._poly_ring_,
'Tbg',
sparse=sparse,
default_prec=default_prec)
self._bg_indeterminate = self._bg_power_series_ring.gen()
self._is_sparse = sparse
self._params = (base_ring, num_gens, name_list, order, default_prec,
sparse)
self._populate_coercion_lists_()
def __init__(self, base_ring, num_gens, name_list,
order='negdeglex', default_prec=10, sparse=False):
"""
Initializes a multivariate power series ring. See PowerSeriesRing
for complete documentation.
INPUT:
- ``base_ring`` -- a commutative ring
- ``num_gens`` -- number of generators
- ``name_list`` -- List of indeterminate names or a single name.
If a single name is given, indeterminates will be this name
followed by a number from 0 to num_gens - 1. If a list is
given, these will be the indeterminate names and the length
of the list must be equal to num_gens.
- ``order`` -- ordering of variables; default is
negative degree lexicographic
- ``default_prec`` -- The default total-degree precision for
elements. The default value of default_prec is 10.
- ``sparse`` -- whether or not the power series are sparse.
The underlying polynomial ring is always sparse.
EXAMPLES::
sage: R.<t,u,v> = PowerSeriesRing(QQ)
sage: g = 1 + v + 3*u*t^2 - 2*v^2*t^2
sage: g = g.add_bigoh(5); g
1 + v + 3*t^2*u - 2*t^2*v^2 + O(t, u, v)^5
sage: g in R
True
TESTS:
By :trac:`14084`, the multi-variate power series ring belongs to the
category of integral domains, if the base ring does::
sage: P = ZZ[['x','y']]
sage: P.category()
Category of integral domains
sage: TestSuite(P).run()
Otherwise, it belongs to the category of commutative rings::
sage: P = Integers(15)[['x','y']]
sage: P.category()
Category of commutative rings
sage: TestSuite(P).run()
"""
order = TermOrder(order,num_gens)
self._term_order = order
if not base_ring.is_commutative():
raise TypeError("Base ring must be a commutative ring.")
n = int(num_gens)
if n < 0:
raise ValueError("Multivariate Polynomial Rings must have more than 0 variables.")
self._ngens = n
self._has_singular = False #cannot convert to Singular by default
# Multivariate power series rings inherit from power series rings. But
# apparently we can not call their initialisation. Instead, initialise
# CommutativeRing and Nonexact:
CommutativeRing.__init__(self, base_ring, name_list, category =
_IntegralDomains if base_ring in
_IntegralDomains else _CommutativeRings)
Nonexact.__init__(self, default_prec)
# underlying polynomial ring in which to represent elements
self._poly_ring_ = PolynomialRing(base_ring, self.variable_names(), order=order)
# because sometimes PowerSeriesRing_generic calls self.__poly_ring
self._PowerSeriesRing_generic__poly_ring = self._poly_ring()
# background univariate power series ring
self._bg_power_series_ring = PowerSeriesRing(self._poly_ring_, 'Tbg', sparse=sparse, default_prec=default_prec)
self._bg_indeterminate = self._bg_power_series_ring.gen()
self._is_sparse = sparse
self._params = (base_ring, num_gens, name_list,
order, default_prec, sparse)
self._populate_coercion_lists_()
def extension(self, poly, name=None, names=None, embedding=None):
if self.modulus() == 1:
return self
else:
from sage.rings.ring import CommutativeRing
return CommutativeRing.extension(self, poly, name, names, embedding)