def __init__(self, ring, category=None):
r"""
Initialize this Ore function field.
TESTS::
sage: k.<a> = GF(11^3)
sage: Frob = k.frobenius_endomorphism()
sage: der = k.derivation(a, twist=Frob)
sage: S.<x> = k['x', der]
sage: K = S.fraction_field()
sage: TestSuite(K).run()
"""
if self.Element is None:
import sage.rings.polynomial.ore_function_element
self.Element = sage.rings.polynomial.ore_function_element.OreFunction
if not isinstance(ring, OrePolynomialRing):
raise TypeError("not a Ore Polynomial Ring")
if ring.base_ring() not in Fields():
raise TypeError("the base ring must be a field")
try:
_ = ring.twisting_morphism(-1)
self._simplification = True
except (TypeError, ZeroDivisionError, NotImplementedError):
self._simplification = False
self._ring = ring
base = ring.base_ring()
category = Algebras(base).or_subcategory(category)
Algebra.__init__(self, base, names=ring.variable_name(), normalize=True, category=category)
def __init__(self,
base_ring,
morphism,
derivation,
name,
sparse,
category=None):
r"""
Initialize ``self``.
INPUT:
- ``base_ring`` -- a commutative ring
- ``morphism`` -- an automorphism of the base ring
- ``derivation`` -- a derivation or a twisted derivation of the base ring
- ``name`` -- string or list of strings representing the name of
the variables of ring
- ``sparse`` -- boolean (default: ``False``)
- ``category`` -- a category
EXAMPLES::
sage: R.<t> = ZZ[]
sage: sigma = R.hom([t+1])
sage: S.<x> = SkewPolynomialRing(R, sigma)
sage: S.category()
Category of algebras over Univariate Polynomial Ring in t over Integer Ring
sage: S([1]) + S([-1])
0
sage: TestSuite(S).run()
"""
if self.Element is None:
import sage.rings.polynomial.ore_polynomial_element
self.Element = sage.rings.polynomial.ore_polynomial_element.OrePolynomial_generic_dense
if self._fraction_field_class is None:
from sage.rings.polynomial.ore_function_field import OreFunctionField
self._fraction_field_class = OreFunctionField
self.__is_sparse = sparse
self._morphism = morphism
self._derivation = derivation
self._fraction_field = None
category = Algebras(base_ring).or_subcategory(category)
Algebra.__init__(self,
base_ring,
names=name,
normalize=True,
category=category)
def __init__(self, base_ring, twist_map, name, sparse, element_class):
r"""
Initialize ``self``.
INPUT:
- ``base_ring`` -- a commutative ring
- ``twist_map`` -- an automorphism of the base ring
- ``name`` -- string or list of strings representing the name of
the variables of ring
- ``sparse`` -- boolean (default: ``False``)
- ``element_class`` -- class representing the type of element to
be used in ring
EXAMPLES::
sage: R.<t> = ZZ[]
sage: sigma = R.hom([t+1])
sage: S.<x> = SkewPolynomialRing(R,sigma)
sage: S([1]) + S([-1])
0
sage: TestSuite(S).run()
sage: k.<t> = GF(5^3)
sage: Frob = k.frobenius_endomorphism()
sage: T.<x> = k['x', Frob]; T
Skew Polynomial Ring in x over Finite Field in t of size 5^3
twisted by t |--> t^5
We skip the pickling tests currently because ``Frob`` does not
pickle correctly (see note on :trac:`13215`)::
sage: TestSuite(T).run(skip=["_test_pickling", "_test_elements"])
"""
self.__is_sparse = sparse
self._polynomial_class = element_class
self._map = twist_map
self._maps = {0: IdentityMorphism(base_ring), 1: self._map}
self._no_generic_basering_coercion = True
Algebra.__init__(self,
base_ring,
names=name,
normalize=True,
category=Rings())
base_inject = SkewPolynomialBaseringInjection(base_ring, self)
self._populate_coercion_lists_(coerce_list=[base_inject],
convert_list=[list, base_inject])
def __init__(self, base_ring, twist_map, name, sparse, element_class):
r"""
Initialize ``self``.
INPUT:
- ``base_ring`` -- a commutative ring
- ``twist_map`` -- an automorphism of the base ring
- ``name`` -- string or list of strings representing the name of
the variables of ring
- ``sparse`` -- boolean (default: ``False``)
- ``element_class`` -- class representing the type of element to
be used in ring
EXAMPLES::
sage: R.<t> = ZZ[]
sage: sigma = R.hom([t+1])
sage: S.<x> = SkewPolynomialRing(R,sigma)
sage: S([1]) + S([-1])
0
sage: TestSuite(S).run()
sage: k.<t> = GF(5^3)
sage: Frob = k.frobenius_endomorphism()
sage: T.<x> = k['x', Frob]; T
Skew Polynomial Ring in x over Finite Field in t of size 5^3
twisted by t |--> t^5
We skip the pickling tests currently because ``Frob`` does not
pickle correctly (see note on :trac:`13215`)::
sage: TestSuite(T).run(skip=["_test_pickling", "_test_elements"])
"""
self.__is_sparse = sparse
self._polynomial_class = element_class
self._map = twist_map
self._maps = {0: IdentityMorphism(base_ring), 1: self._map}
self._no_generic_basering_coercion = True
Algebra.__init__(self, base_ring, names=name,
normalize=True, category=Rings())
base_inject = SkewPolynomialBaseringInjection(base_ring, self)
self._populate_coercion_lists_(
coerce_list = [base_inject],
convert_list = [list, base_inject])
def __init__(self,
k,
table,
names='e',
assume_associative=False,
category=None):
"""
TESTS::
sage: A = FiniteDimensionalAlgebra(QQ, [])
sage: A
Finite-dimensional algebra of degree 0 over Rational Field
sage: type(A)
<class 'sage.algebras.finite_dimensional_algebras.finite_dimensional_algebra.FiniteDimensionalAlgebra_with_category'>
sage: TestSuite(A).run()
sage: B = FiniteDimensionalAlgebra(GF(7), [Matrix([1])])
sage: B
Finite-dimensional algebra of degree 1 over Finite Field of size 7
sage: TestSuite(B).run()
sage: C = FiniteDimensionalAlgebra(CC, [Matrix([[1, 0], [0, 1]]), Matrix([[0, 1], [0, 0]])])
sage: C
Finite-dimensional algebra of degree 2 over Complex Field with 53 bits of precision
sage: TestSuite(C).run()
sage: FiniteDimensionalAlgebra(GF(3), [Matrix([[1, 0], [0, 1]])])
Traceback (most recent call last):
...
ValueError: input is not a multiplication table
sage: D.<a,b> = FiniteDimensionalAlgebra(RR, [Matrix([[1, 0], [0, 1]]), Matrix([[0, 1], [-1, 0]])])
sage: D.gens()
(a, b)
sage: E = FiniteDimensionalAlgebra(QQ, [Matrix([0])])
sage: E.gens()
(e,)
"""
n = len(table)
self._table = [b.base_extend(k) for b in table]
if not all([is_Matrix(b) and b.dimensions() == (n, n) for b in table]):
raise ValueError("input is not a multiplication table")
self._assume_associative = assume_associative
# No further validity checks necessary!
if category is None:
category = FiniteDimensionalAlgebrasWithBasis(k)
Algebra.__init__(self, base_ring=k, names=names, category=category)
def __init__(self, R, names=None):
r"""
Initialize ``self``.
EXAMPLES::
sage: R.<x,y,z> = QQ[]
sage: W = DifferentialWeylAlgebra(R)
sage: TestSuite(W).run()
"""
self._n = len(names)
self._poly_ring = PolynomialRing(R, names)
names = names + tuple('d' + n for n in names)
if len(names) != self._n * 2:
raise ValueError("variable names cannot differ by a leading 'd'")
# TODO: Make this into a filtered algebra under the natural grading of
# x_i and dx_i have degree 1
Algebra.__init__(self, R, names, category=AlgebrasWithBasis(R).NoZeroDivisors())
def __init__(self, k, table, names='e', assume_associative=False, category=None):
"""
TESTS::
sage: A = FiniteDimensionalAlgebra(QQ, [])
sage: A
Finite-dimensional algebra of degree 0 over Rational Field
sage: type(A)
<class 'sage.algebras.finite_dimensional_algebras.finite_dimensional_algebra.FiniteDimensionalAlgebra_with_category'>
sage: TestSuite(A).run()
sage: B = FiniteDimensionalAlgebra(GF(7), [Matrix([1])])
sage: B
Finite-dimensional algebra of degree 1 over Finite Field of size 7
sage: TestSuite(B).run()
sage: C = FiniteDimensionalAlgebra(CC, [Matrix([[1, 0], [0, 1]]), Matrix([[0, 1], [0, 0]])])
sage: C
Finite-dimensional algebra of degree 2 over Complex Field with 53 bits of precision
sage: TestSuite(C).run()
sage: FiniteDimensionalAlgebra(GF(3), [Matrix([[1, 0], [0, 1]])])
Traceback (most recent call last):
...
ValueError: input is not a multiplication table
sage: D.<a,b> = FiniteDimensionalAlgebra(RR, [Matrix([[1, 0], [0, 1]]), Matrix([[0, 1], [-1, 0]])])
sage: D.gens()
(a, b)
sage: E = FiniteDimensionalAlgebra(QQ, [Matrix([0])])
sage: E.gens()
(e,)
"""
n = len(table)
self._table = [b.base_extend(k) for b in table]
if not all([is_Matrix(b) and b.dimensions() == (n, n) for b in table]):
raise ValueError("input is not a multiplication table")
self._assume_associative = assume_associative
# No further validity checks necessary!
if category is None:
category = FiniteDimensionalAlgebrasWithBasis(k)
Algebra.__init__(self, base_ring=k, names=names, category=category)
def __init__(self, R, names=None):
r"""
Initialize ``self``.
EXAMPLES::
sage: R.<x,y,z> = QQ[]
sage: W = DifferentialWeylAlgebra(R)
sage: TestSuite(W).run()
"""
self._n = len(names)
self._poly_ring = PolynomialRing(R, names)
names = names + tuple('d' + n for n in names)
if len(names) != self._n * 2:
raise ValueError("variable names cannot differ by a leading 'd'")
# TODO: Make this into a filtered algebra under the natural grading of
# x_i and dx_i have degree 1
Algebra.__init__(self,
R,
names,
category=AlgebrasWithBasis(R).NoZeroDivisors())
def __init__(self, k, table, names='e', category=None):
"""
TESTS::
sage: A = FiniteDimensionalAlgebra(QQ, [])
sage: A
Finite-dimensional algebra of degree 0 over Rational Field
sage: type(A)
<class 'sage.algebras.finite_dimensional_algebras.finite_dimensional_algebra.FiniteDimensionalAlgebra_with_category'>
sage: TestSuite(A).run()
sage: B = FiniteDimensionalAlgebra(GF(7), [Matrix([1])])
sage: B
Finite-dimensional algebra of degree 1 over Finite Field of size 7
sage: TestSuite(B).run()
sage: C = FiniteDimensionalAlgebra(CC, [Matrix([[1, 0], [0, 1]]), Matrix([[0, 1], [0, 0]])])
sage: C
Finite-dimensional algebra of degree 2 over Complex Field with 53 bits of precision
sage: TestSuite(C).run()
sage: FiniteDimensionalAlgebra(GF(3), [Matrix([[1, 0], [0, 1]])])
Traceback (most recent call last):
...
ValueError: input is not a multiplication table
sage: D.<a,b> = FiniteDimensionalAlgebra(RR, [Matrix([[1, 0], [0, 1]]), Matrix([[0, 1], [-1, 0]])])
sage: D.gens()
(a, b)
sage: E = FiniteDimensionalAlgebra(QQ, [Matrix([0])])
sage: E.gens()
(e,)
"""
self._table = table
self._assume_associative = "Associative" in category.axioms()
# No further validity checks necessary!
Algebra.__init__(self, base_ring=k, names=names, category=category)
def __init__(self, k, table, names='e', category=None):
"""
TESTS::
sage: A = FiniteDimensionalAlgebra(QQ, [])
sage: A
Finite-dimensional algebra of degree 0 over Rational Field
sage: type(A)
<class 'sage.algebras.finite_dimensional_algebras.finite_dimensional_algebra.FiniteDimensionalAlgebra_with_category'>
sage: TestSuite(A).run()
sage: B = FiniteDimensionalAlgebra(GF(7), [Matrix([1])])
sage: B
Finite-dimensional algebra of degree 1 over Finite Field of size 7
sage: TestSuite(B).run()
sage: C = FiniteDimensionalAlgebra(CC, [Matrix([[1, 0], [0, 1]]), Matrix([[0, 1], [0, 0]])])
sage: C
Finite-dimensional algebra of degree 2 over Complex Field with 53 bits of precision
sage: TestSuite(C).run()
sage: FiniteDimensionalAlgebra(GF(3), [Matrix([[1, 0], [0, 1]])])
Traceback (most recent call last):
...
ValueError: input is not a multiplication table
sage: D.<a,b> = FiniteDimensionalAlgebra(RR, [Matrix([[1, 0], [0, 1]]), Matrix([[0, 1], [-1, 0]])])
sage: D.gens()
(a, b)
sage: E = FiniteDimensionalAlgebra(QQ, [Matrix([0])])
sage: E.gens()
(e,)
"""
self._table = table
self._assume_associative = "Associative" in category.axioms()
# No further validity checks necessary!
Algebra.__init__(self, base_ring=k, names=names, category=category)
def __init__(self, base_ring, twist_map, derivation, name, sparse=False):
r"""
INPUT :
- ''base_ring'' -- a commutative ring
- ''twist_map'' -- an automorphism of the base ring
- ''derivation'' -- a derivation of the base ring
- ''name'' --string or list od strings representing the name of
the variables of ring
- ''sparse'' -- boolean (defaut : ''False'')
- ''element_class'' -- class representing the type of element to be used in ring
"""
if sparse:
raise NotImplementedError()
self._is_sparse = sparse
self.Element = OrePolynomial1
self._map = twist_map
self._derivation = derivation
Algebra.__init__(self,
base_ring,
names=name,
normalize=True,
category=Rings())