def __init__(self, base_module, names=None, name=None,
star_product_terms={}, default_prec=2):
"""
Kontsevich graph series rng (ring without identity).
EXAMPLES::
sage: K = KontsevichGraphSums(QQ)
sage: star_product_terms = {0 : K([(1, KontsevichGraph({'F' : {}, \
....: 'G' : {}}, ground_vertices=('F','G'), immutable=True))])}
sage: S.<h> = KontsevichGraphSeriesRng(K, star_product_terms = \
....: star_product_terms, default_prec = 0)
"""
Parent.__init__(self, base_module.base_ring(),
category=AssociativeAlgebras(base_module.base_ring()))
Nonexact.__init__(self, default_prec)
self._base_module = base_module
if name:
self._generator = name
elif names:
self._generator = names[0]
else:
raise ValueError('Must provide a name for the generator')
self._star_product_series = {}
self._star_product_series = self.element_class(self, star_product_terms,
prec=default_prec)
def __init__(self,
base_ring,
name=None,
default_prec=20,
sparse=False,
use_lazy_mpoly_ring=False,
category=None):
"""
Initializes a power series ring.
INPUT:
- ``base_ring`` - a commutative ring
- ``name`` - name of the indeterminate
- ``default_prec`` - the default precision
- ``sparse`` - whether or not power series are
sparse
- ``use_lazy_mpoly_ring`` - if base ring is a poly ring compute with
multivariate polynomials instead of a univariate poly over the base
ring. Only use this for dense power series where you won't do too
much arithmetic, but the arithmetic you do must be fast. You must
explicitly call ``f.do_truncation()`` on an element
for it to truncate away higher order terms (this is called
automatically before printing).
"""
R = PolynomialRing(base_ring, name, sparse=sparse)
self.__poly_ring = R
self.__is_sparse = sparse
self.__params = (base_ring, name, default_prec, sparse)
if use_lazy_mpoly_ring and (is_MPolynomialRing(base_ring) or \
is_PolynomialRing(base_ring)):
K = base_ring
names = K.variable_names() + (name, )
self.__mpoly_ring = PolynomialRing(K.base_ring(), names=names)
assert is_MPolynomialRing(self.__mpoly_ring)
self.Element = power_series_mpoly.PowerSeries_mpoly
commutative_ring.CommutativeRing.__init__(
self,
base_ring,
names=name,
category=getattr(self, '_default_category', _CommutativeRings))
Nonexact.__init__(self, default_prec)
self.__generator = self.element_class(self,
R.gen(),
check=True,
is_gen=True)
def __init__(self, base_ring, name=None, default_prec=20, sparse=False,
use_lazy_mpoly_ring=False):
"""
Initializes a power series ring.
INPUT:
- ``base_ring`` - a commutative ring
- ``name`` - name of the indeterminate
- ``default_prec`` - the default precision
- ``sparse`` - whether or not power series are
sparse
- ``use_lazy_mpoly_ring`` - if base ring is a poly ring compute with
multivariate polynomials instead of a univariate poly over the base
ring. Only use this for dense power series where you won't do too
much arithmetic, but the arithmetic you do must be fast. You must
explicitly call ``f.do_truncation()`` on an element
for it to truncate away higher order terms (this is called
automatically before printing).
"""
R = PolynomialRing(base_ring, name, sparse=sparse)
self.__poly_ring = R
self.__is_sparse = sparse
self.__params = (base_ring, name, default_prec, sparse)
if use_lazy_mpoly_ring and (is_MPolynomialRing(base_ring) or \
is_PolynomialRing(base_ring)):
K = base_ring
names = K.variable_names() + (name,)
self.__mpoly_ring = PolynomialRing(K.base_ring(), names=names)
assert is_MPolynomialRing(self.__mpoly_ring)
self.Element = power_series_mpoly.PowerSeries_mpoly
commutative_ring.CommutativeRing.__init__(self, base_ring, names=name,
category=getattr(self,'_default_category',
_CommutativeRings))
Nonexact.__init__(self, default_prec)
self.__generator = self.element_class(self, R.gen(), check=True, is_gen=True)
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 power series are 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(),
sparse=sparse,
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 power series are 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(), sparse=sparse, 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, name=None, default_prec=None, sparse=False,
use_lazy_mpoly_ring=False, category=None):
"""
Initializes a power series ring.
INPUT:
- ``base_ring`` - a commutative ring
- ``name`` - name of the indeterminate
- ``default_prec`` - the default precision
- ``sparse`` - whether or not power series are
sparse
- ``use_lazy_mpoly_ring`` - if base ring is a poly ring compute with
multivariate polynomials instead of a univariate poly over the base
ring. Only use this for dense power series where you won't do too
much arithmetic, but the arithmetic you do must be fast. You must
explicitly call ``f.do_truncation()`` on an element
for it to truncate away higher order terms (this is called
automatically before printing).
EXAMPLES:
This base class inherits from :class:`~sage.rings.ring.CommutativeRing`.
Since :trac:`11900`, it is also initialised as such, and since :trac:`14084`
it is actually initialised as an integral domain::
sage: R.<x> = ZZ[[]]
sage: R.category()
Category of integral domains
sage: TestSuite(R).run()
When the base ring `k` is a field, the ring `k[[x]]` is not only a
commutative ring, but also a complete discrete valuation ring (CDVR).
The appropriate (sub)category is automatically set in this case::
sage: k = GF(11)
sage: R.<x> = k[[]]
sage: R.category()
Category of complete discrete valuation rings
sage: TestSuite(R).run()
"""
R = PolynomialRing(base_ring, name, sparse=sparse)
self.__poly_ring = R
self.__is_sparse = sparse
if default_prec is None:
from sage.misc.defaults import series_precision
default_prec = series_precision()
self.__params = (base_ring, name, default_prec, sparse)
if use_lazy_mpoly_ring and (is_MPolynomialRing(base_ring) or \
is_PolynomialRing(base_ring)):
K = base_ring
names = K.variable_names() + (name,)
self.__mpoly_ring = PolynomialRing(K.base_ring(), names=names)
assert is_MPolynomialRing(self.__mpoly_ring)
self.Element = power_series_mpoly.PowerSeries_mpoly
commutative_ring.CommutativeRing.__init__(self, base_ring, names=name,
category=getattr(self,'_default_category',
_CommutativeRings))
Nonexact.__init__(self, default_prec)
self.__generator = self.element_class(self, R.gen(), check=True, is_gen=True)
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 power series are 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
"""
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
ParentWithGens.__init__(self, base_ring, name_list)
Nonexact.__init__(self, default_prec)
# underlying polynomial ring in which to represent elements
self._poly_ring_ = PolynomialRing(base_ring, self.variable_names(), sparse=sparse, 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()
## use the following in PowerSeriesRing_generic.__call__
self._PowerSeriesRing_generic__power_series_class = MPowerSeries
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,
name=None,
default_prec=None,
sparse=False,
use_lazy_mpoly_ring=False,
category=None):
"""
Initializes a power series ring.
INPUT:
- ``base_ring`` - a commutative ring
- ``name`` - name of the indeterminate
- ``default_prec`` - the default precision
- ``sparse`` - whether or not power series are
sparse
- ``use_lazy_mpoly_ring`` - if base ring is a poly ring compute with
multivariate polynomials instead of a univariate poly over the base
ring. Only use this for dense power series where you won't do too
much arithmetic, but the arithmetic you do must be fast. You must
explicitly call ``f.do_truncation()`` on an element
for it to truncate away higher order terms (this is called
automatically before printing).
EXAMPLES:
This base class inherits from :class:`~sage.rings.ring.CommutativeRing`.
Since :trac:`11900`, it is also initialised as such, and since :trac:`14084`
it is actually initialised as an integral domain::
sage: R.<x> = ZZ[[]]
sage: R.category()
Category of integral domains
sage: TestSuite(R).run()
When the base ring `k` is a field, the ring `k[[x]]` is not only a
commutative ring, but also a complete discrete valuation ring (CDVR).
The appropriate (sub)category is automatically set in this case::
sage: k = GF(11)
sage: R.<x> = k[[]]
sage: R.category()
Category of complete discrete valuation rings
sage: TestSuite(R).run()
It is checked that the default precision is non-negative
(see :trac:`19409`)::
sage: PowerSeriesRing(ZZ, 'x', default_prec=-5)
Traceback (most recent call last):
...
ValueError: default_prec (= -5) must be non-negative
"""
R = PolynomialRing(base_ring, name, sparse=sparse)
self.__poly_ring = R
self.__is_sparse = sparse
if default_prec is None:
from sage.misc.defaults import series_precision
default_prec = series_precision()
elif default_prec < 0:
raise ValueError("default_prec (= %s) must be non-negative" %
default_prec)
self.__params = (base_ring, name, default_prec, sparse)
if use_lazy_mpoly_ring and (is_MPolynomialRing(base_ring) or \
is_PolynomialRing(base_ring)):
K = base_ring
names = K.variable_names() + (name, )
self.__mpoly_ring = PolynomialRing(K.base_ring(), names=names)
assert is_MPolynomialRing(self.__mpoly_ring)
self.Element = power_series_mpoly.PowerSeries_mpoly
commutative_ring.CommutativeRing.__init__(
self,
base_ring,
names=name,
category=getattr(self, '_default_category', _CommutativeRings))
Nonexact.__init__(self, default_prec)
self.__generator = self.element_class(self,
R.gen(),
check=True,
is_gen=True)
def __init__(self, base_ring, name=None, default_prec=None, sparse=False,
use_lazy_mpoly_ring=None, implementation=None,
category=None):
"""
Initializes a power series ring.
INPUT:
- ``base_ring`` - a commutative ring
- ``name`` - name of the indeterminate
- ``default_prec`` - the default precision
- ``sparse`` - whether or not power series are
sparse
- ``implementation`` -- either ``'poly'``, ``'mpoly'``, or
``'pari'``. The default is ``'pari'`` if the base field is
a PARI finite field, and ``'poly'`` otherwise.
- ``use_lazy_mpoly_ring`` -- This option is deprecated; use
``implementation='mpoly'`` instead.
If the base ring is a polynomial ring, then the option
``implementation='mpoly'`` causes computations to be done with
multivariate polynomials instead of a univariate polynomial
ring over the base ring. Only use this for dense power series
where you won't do too much arithmetic, but the arithmetic you
do must be fast. You must explicitly call
``f.do_truncation()`` on an element for it to truncate away
higher order terms (this is called automatically before
printing).
EXAMPLES:
This base class inherits from :class:`~sage.rings.ring.CommutativeRing`.
Since :trac:`11900`, it is also initialised as such, and since :trac:`14084`
it is actually initialised as an integral domain::
sage: R.<x> = ZZ[[]]
sage: R.category()
Category of integral domains
sage: TestSuite(R).run()
When the base ring `k` is a field, the ring `k[[x]]` is not only a
commutative ring, but also a complete discrete valuation ring (CDVR).
The appropriate (sub)category is automatically set in this case::
sage: k = GF(11)
sage: R.<x> = k[[]]
sage: R.category()
Category of complete discrete valuation rings
sage: TestSuite(R).run()
It is checked that the default precision is non-negative
(see :trac:`19409`)::
sage: PowerSeriesRing(ZZ, 'x', default_prec=-5)
Traceback (most recent call last):
...
ValueError: default_prec (= -5) must be non-negative
"""
if use_lazy_mpoly_ring is not None:
deprecation(15601, 'The option use_lazy_mpoly_ring is deprecated; use implementation="mpoly" instead')
from sage.rings.finite_rings.finite_field_pari_ffelt import FiniteField_pari_ffelt
if implementation is None:
if isinstance(base_ring, FiniteField_pari_ffelt):
implementation = 'pari'
elif use_lazy_mpoly_ring and (is_MPolynomialRing(base_ring) or
is_PolynomialRing(base_ring)):
implementation = 'mpoly'
else:
implementation = 'poly'
R = PolynomialRing(base_ring, name, sparse=sparse)
self.__poly_ring = R
self.__is_sparse = sparse
if default_prec is None:
from sage.misc.defaults import series_precision
default_prec = series_precision()
elif default_prec < 0:
raise ValueError("default_prec (= %s) must be non-negative"
% default_prec)
if implementation == 'poly':
self.Element = power_series_poly.PowerSeries_poly
elif implementation == 'mpoly':
K = base_ring
names = K.variable_names() + (name,)
self.__mpoly_ring = PolynomialRing(K.base_ring(), names=names)
assert is_MPolynomialRing(self.__mpoly_ring)
self.Element = power_series_mpoly.PowerSeries_mpoly
elif implementation == 'pari':
self.Element = PowerSeries_pari
else:
raise ValueError('unknown power series implementation: %r' % implementation)
ring.CommutativeRing.__init__(self, base_ring, names=name,
category=getattr(self, '_default_category',
_CommutativeRings))
Nonexact.__init__(self, default_prec)
if self.Element is PowerSeries_pari:
self.__generator = self.element_class(self, R.gen().__pari__())
else:
self.__generator = self.element_class(self, R.gen(), is_gen=True)
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 power series are 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
"""
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
ParentWithGens.__init__(self, base_ring, name_list)
Nonexact.__init__(self, default_prec)
# underlying polynomial ring in which to represent elements
self._poly_ring_ = PolynomialRing(base_ring,
self.variable_names(),
sparse=sparse,
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()
## use the following in PowerSeriesRing_generic.__call__
self._PowerSeriesRing_generic__power_series_class = MPowerSeries
self._is_sparse = sparse
self._params = (base_ring, num_gens, name_list, order, default_prec,
sparse)
self._populate_coercion_lists_()
