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