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, root_system, base_ring):
"""
EXAMPLES::
sage: P = RootSystem(['A',4]).root_space()
sage: s = P.simple_reflections()
"""
from sage.categories.morphism import SetMorphism
from sage.categories.homset import Hom
from sage.categories.sets_with_partial_maps import SetsWithPartialMaps
self.root_system = root_system
CombinatorialFreeModule.__init__(
self,
base_ring,
root_system.index_set(),
prefix="alphacheck" if root_system.dual_side else "alpha",
latex_prefix="\\alpha^\\vee"
if root_system.dual_side else "\\alpha",
category=RootLatticeRealizations(base_ring))
if base_ring is not ZZ:
# Register the partial conversion back from ``self`` to the root lattice
# See :meth:`_to_root_lattice` for tests
root_lattice = self.root_system.root_lattice()
SetMorphism(Hom(self, root_lattice, SetsWithPartialMaps()),
self._to_root_lattice).register_as_conversion()
def __init__(self, kBoundedRing):
r"""
TESTS::
sage: Sym = SymmetricFunctions(QQ)
sage: from sage.combinat.sf.new_kschur import kHomogeneous
sage: KB = Sym.kBoundedSubspace(3,t=1)
sage: kHomogeneous(KB)
3-bounded Symmetric Functions over Rational Field with t=1 in the 3-bounded homogeneous basis
"""
CombinatorialFreeModule.__init__(self, kBoundedRing.base_ring(),
kBoundedRing.indices(),
category= KBoundedSubspaceBases(kBoundedRing, kBoundedRing.t),
prefix='h%d'%kBoundedRing.k)
self._kBoundedRing = kBoundedRing
self.k = kBoundedRing.k
h = self.realization_of().ambient().homogeneous()
self.lift = self._module_morphism(lambda x: h[x],
codomain=h, triangular='lower', unitriangular=True,
inverse_on_support=lambda p:p if p.get_part(0) <= self.k else None)
self.ambient = ConstantFunction(h)
self.lift.register_as_coercion()
self.retract = SetMorphism(Hom(h, self, SetsWithPartialMaps()),
self.lift.preimage)
self.register_conversion(self.retract)
def super_categories(self):
r"""
We include SetsWithPartialMaps between Sets and Objects so that we
can define morphisms between sets that are only partially defined.
This is also to have the Homset constructor not complain that
SetsWithPartialMaps is not a supercategory of Fields, for example.
EXAMPLES::
sage: Sets().super_categories()
[Category of sets with partial maps]
"""
return [SetsWithPartialMaps()]
def __init__(self, S, R):
"""
Initialization.
EXAMPLES::
sage: K.<a> = Qq(2^10)
sage: R.<x> = K[]
sage: W.<w> = K.extension(x^4 + 2*a*x^2 - 16*x - 6*a)
sage: f = K.convert_map_from(W); type(f)
<class 'sage.rings.padics.relative_extension_leaves.pAdicRelativeBaseringSection'>
"""
from sage.categories.sets_with_partial_maps import SetsWithPartialMaps
Morphism.__init__(self, Hom(S, R, SetsWithPartialMaps()))
def section(self):
r"""
Return a section of this map.
EXAMPLES::
sage: R.<x> = QQ[]
sage: R.fraction_field().coerce_map_from(R).section()
Section map:
From: Fraction Field of Univariate Polynomial Ring in x over Rational Field
To: Univariate Polynomial Ring in x over Rational Field
"""
from sage.categories.sets_with_partial_maps import SetsWithPartialMaps
from sage.all import Hom
parent = Hom(self.codomain(), self.domain(), SetsWithPartialMaps())
return parent.__make_element_class__(FractionFieldEmbeddingSection)(self)
def __init__(self, R, S):
"""
Initialization.
EXAMPLES::
sage: K.<a> = Qq(125)
sage: R.<x> = K[]
sage: W.<w> = K.extension(x^3 + 15*a*x - 5*(1+a^2))
sage: f = W.coerce_map_from(K)
sage: type(f)
<class 'sage.rings.padics.relative_extension_leaves.pAdicRelativeBaseringInjection'>
"""
if not R.is_field() or S.is_field():
Morphism.__init__(self, Hom(R, S))
else:
from sage.categories.sets_with_partial_maps import SetsWithPartialMaps
Morphism.__init__(self, Hom(R, S, SetsWithPartialMaps()))
def _create_(R, k):
"""
Initialization. We have to implement this as a static method
in order to call ``__make_element_class__``.
INPUT:
- ``R`` -- a `p`-adic ring or field.
- ``k`` -- the residue field of ``R``, or a residue ring of ``R``.
EXAMPLES::
sage: f = Zmod(49).convert_map_from(Zp(7))
sage: TestSuite(f).run()
sage: K.<a> = Qq(125); k = K.residue_field(); f = k.convert_map_from(K)
sage: TestSuite(f).run()
"""
if R.is_field():
from sage.categories.sets_with_partial_maps import SetsWithPartialMaps
cat = SetsWithPartialMaps()
else:
from sage.categories.rings import Rings
cat = Rings()
from sage.categories.homset import Hom
kfield = R.residue_field()
N = k.cardinality()
q = kfield.cardinality()
n = N.exact_log(q)
if N != q**n:
raise RuntimeError("N must be a power of q")
H = Hom(R, k, cat)
f = H.__make_element_class__(ResidueReductionMap)(H)
f._n = n
if kfield is k:
f._field = True
else:
f._field = False
return f
