def _single_variate(base_ring, name, sparse, implementation): import sage.rings.polynomial.polynomial_ring as m name = normalize_names(1, name) key = (base_ring, name, sparse, implementation if not sparse else None) R = _get_from_cache(key) if not R is None: return R if isinstance(base_ring, ring.CommutativeRing): if is_IntegerModRing(base_ring) and not sparse: n = base_ring.order() if n.is_prime(): R = m.PolynomialRing_dense_mod_p(base_ring, name, implementation=implementation) elif n > 1: R = m.PolynomialRing_dense_mod_n(base_ring, name, implementation=implementation) else: # n == 1! R = m.PolynomialRing_integral_domain( base_ring, name) # specialized code breaks in this case. elif is_FiniteField(base_ring) and not sparse: R = m.PolynomialRing_dense_finite_field( base_ring, name, implementation=implementation) elif isinstance(base_ring, padic_base_leaves.pAdicFieldCappedRelative): R = m.PolynomialRing_dense_padic_field_capped_relative( base_ring, name) elif isinstance(base_ring, padic_base_leaves.pAdicRingCappedRelative): R = m.PolynomialRing_dense_padic_ring_capped_relative( base_ring, name) elif isinstance(base_ring, padic_base_leaves.pAdicRingCappedAbsolute): R = m.PolynomialRing_dense_padic_ring_capped_absolute( base_ring, name) elif isinstance(base_ring, padic_base_leaves.pAdicRingFixedMod): R = m.PolynomialRing_dense_padic_ring_fixed_mod(base_ring, name) elif base_ring.is_field(proof=False): R = m.PolynomialRing_field(base_ring, name, sparse) elif base_ring.is_integral_domain(proof=False): R = m.PolynomialRing_integral_domain(base_ring, name, sparse, implementation) else: R = m.PolynomialRing_commutative(base_ring, name, sparse) else: R = m.PolynomialRing_general(base_ring, name, sparse) if hasattr(R, '_implementation_names'): for name in R._implementation_names: real_key = key[0:3] + (name, ) _save_in_cache(real_key, R) else: _save_in_cache(key, R) return R
def _single_variate(base_ring, names, sparse): """ EXAMPLES:: sage: from sage.rings.polynomial.laurent_polynomial_ring import _single_variate sage: _single_variate(QQ, ('x',), False) Univariate Laurent Polynomial Ring in x over Rational Field """ ############################################################ # This should later get moved to an actual single variate # # implementation with valuation tracking, # # but I don't want to right now. # ############################################################ # We need to come up with a name for the inverse that is easy to search # for in a string *and* doesn't overlap with the name that we already have. # For now, I'm going to use a name mangling with checking method. names = normalize_names(1, names) key = (base_ring, names, sparse) P = _get_from_cache(key) if P is not None: return P prepend_string = "qk" while True: if prepend_string in names: prepend_string += 'k' else: break R = _multi_variate_poly(base_ring, names, 1, sparse, 'degrevlex', None) P = LaurentPolynomialRing_mpair(R, prepend_string, names) _save_in_cache(key, P) return P
def create_key_and_extra_args(self, order, name=None, modulus=None, names=None, impl=None, proof=None, **kwds): """ EXAMPLES:: sage: GF.create_key_and_extra_args(9, 'a') ((9, ('a',), 'conway', None, '{}', 3, 2, True), {}) sage: GF.create_key_and_extra_args(9, 'a', foo='value') ((9, ('a',), 'conway', None, "{'foo': 'value'}", 3, 2, True), {'foo': 'value'}) """ from sage.structure.proof.all import WithProof, arithmetic if proof is None: proof = arithmetic() with WithProof('arithmetic', proof): order = int(order) if order <= 1: raise ValueError("the order of a finite field must be > 1.") if arith.is_prime(order): name = None modulus = None p = integer.Integer(order) n = integer.Integer(1) elif arith.is_prime_power(order): if not names is None: name = names name = normalize_names(1, name) p, n = arith.factor(order)[0] if modulus is None or modulus == "default": if exists_conway_polynomial(p, n): modulus = "conway" else: if p == 2: modulus = "minimal_weight" else: modulus = "random" elif modulus == "random": modulus += str(random.randint(0, 1 << 128)) if isinstance(modulus, (list, tuple)): modulus = FiniteField(p)['x'](modulus) # some classes use 'random' as the modulus to # generate a random modulus, but we don't want # to cache it elif sage.rings.polynomial.polynomial_element.is_Polynomial( modulus): modulus = modulus.change_variable_name('x') elif not isinstance(modulus, str): raise ValueError("Modulus parameter not understood.") else: # Neither a prime, nor a prime power raise ValueError( "the order of a finite field must be a prime power.") return (order, name, modulus, impl, str(kwds), p, n, proof), kwds
def _single_variate(base_ring, names, sparse): """ EXAMPLES:: sage: from sage.rings.polynomial.laurent_polynomial_ring import _single_variate sage: _single_variate(QQ, ('x',), False) Univariate Laurent Polynomial Ring in x over Rational Field """ ############################################################ # This should later get moved to an actual single variate # # implementation with valuation tracking, # # but I don't want to right now. # ############################################################ # We need to come up with a name for the inverse that is easy to search # for in a string *and* doesn't overlap with the name that we already have. # For now, I'm going to use a name mangling with checking method. names = normalize_names(1, names) key = (base_ring, names, sparse) P = _get_from_cache(key) if P is not None: return P prepend_string = "qk" while True: if prepend_string in names: prepend_string += 'k' else: break R = _multi_variate_poly(base_ring, names, 1, sparse, 'degrevlex', None) P = LaurentPolynomialRing_mpair(R, prepend_string, names) _save_in_cache(key, P) return P
def AffineSpace(n, R=None, names='x'): r""" Return affine space of dimension `n` over the ring `R`. EXAMPLES: The dimension and ring can be given in either order:: sage: AffineSpace(3, QQ, 'x') Affine Space of dimension 3 over Rational Field sage: AffineSpace(5, QQ, 'x') Affine Space of dimension 5 over Rational Field sage: A = AffineSpace(2, QQ, names='XY'); A Affine Space of dimension 2 over Rational Field sage: A.coordinate_ring() Multivariate Polynomial Ring in X, Y over Rational Field Use the divide operator for base extension:: sage: AffineSpace(5, names='x')/GF(17) Affine Space of dimension 5 over Finite Field of size 17 The default base ring is `\ZZ`:: sage: AffineSpace(5, names='x') Affine Space of dimension 5 over Integer Ring There is also an affine space associated to each polynomial ring:: sage: R = GF(7)['x,y,z'] sage: A = AffineSpace(R); A Affine Space of dimension 3 over Finite Field of size 7 sage: A.coordinate_ring() is R True """ if is_MPolynomialRing(n) and R is None: R = n A = AffineSpace(R.ngens(), R.base_ring(), R.variable_names()) A._coordinate_ring = R return A if isinstance(R, (int, long, Integer)): n, R = R, n if R is None: R = ZZ # default is the integers if names is None: if n == 0: names = '' else: raise TypeError( "You must specify the variables names of the coordinate ring.") names = normalize_names(n, names) if R in _Fields: if is_FiniteField(R): return AffineSpace_finite_field(n, R, names) else: return AffineSpace_field(n, R, names) return AffineSpace_generic(n, R, names)
def AffineSpace(n, R=None, names='x'): r""" Return affine space of dimension `n` over the ring `R`. EXAMPLES: The dimension and ring can be given in either order:: sage: AffineSpace(3, QQ, 'x') Affine Space of dimension 3 over Rational Field sage: AffineSpace(5, QQ, 'x') Affine Space of dimension 5 over Rational Field sage: A = AffineSpace(2, QQ, names='XY'); A Affine Space of dimension 2 over Rational Field sage: A.coordinate_ring() Multivariate Polynomial Ring in X, Y over Rational Field Use the divide operator for base extension:: sage: AffineSpace(5, names='x')/GF(17) Affine Space of dimension 5 over Finite Field of size 17 The default base ring is `\ZZ`:: sage: AffineSpace(5, names='x') Affine Space of dimension 5 over Integer Ring There is also an affine space associated to each polynomial ring:: sage: R = GF(7)['x,y,z'] sage: A = AffineSpace(R); A Affine Space of dimension 3 over Finite Field of size 7 sage: A.coordinate_ring() is R True """ if is_MPolynomialRing(n) and R is None: R = n A = AffineSpace(R.ngens(), R.base_ring(), R.variable_names()) A._coordinate_ring = R return A if isinstance(R, (int, long, Integer)): n, R = R, n if R is None: R = ZZ # default is the integers if names is None: if n == 0: names = '' else: raise TypeError("You must specify the variables names of the coordinate ring.") names = normalize_names(n, names) if R in _Fields: if is_FiniteField(R): return AffineSpace_finite_field(n, R, names) else: return AffineSpace_field(n, R, names) return AffineSpace_generic(n, R, names)
def __init__(self, n, R=ZZ, names=None): """ EXAMPLES:: sage: ProjectiveSpace(3, Zp(5), 'y') Projective Space of dimension 3 over 5-adic Ring with capped relative precision 20 """ names = normalize_names(n + 1, names) AmbientSpace.__init__(self, n, R) self._assign_names(names)
def __init__(self, n, R, names): """ EXAMPLES:: sage: AffineSpace(3, Zp(5), 'y') Affine Space of dimension 3 over 5-adic Ring with capped relative precision 20 """ names = normalize_names(n, names) AmbientSpace.__init__(self, n, R) self._assign_names(names)
def __init__(self, n, R=ZZ, names=None): """ EXAMPLES:: sage: ProjectiveSpace(3, Zp(5), 'y') Projective Space of dimension 3 over 5-adic Ring with capped relative precision 20 """ names = normalize_names(n+1, names) AmbientSpace.__init__(self, n, R) self._assign_names(names)
def create_key_and_extra_args(self, order, name=None, modulus=None, names=None, impl=None, proof=None, **kwds): """ EXAMPLES:: sage: GF.create_key_and_extra_args(9, 'a') ((9, ('a',), 'conway', None, '{}', 3, 2, True), {}) sage: GF.create_key_and_extra_args(9, 'a', foo='value') ((9, ('a',), 'conway', None, "{'foo': 'value'}", 3, 2, True), {'foo': 'value'}) """ from sage.structure.proof.all import WithProof, arithmetic if proof is None: proof = arithmetic() with WithProof("arithmetic", proof): order = int(order) if order <= 1: raise ValueError("the order of a finite field must be > 1.") if arith.is_prime(order): name = None modulus = None p = integer.Integer(order) n = integer.Integer(1) elif arith.is_prime_power(order): if not names is None: name = names name = normalize_names(1, name) p, n = arith.factor(order)[0] if modulus is None or modulus == "default": if exists_conway_polynomial(p, n): modulus = "conway" else: if p == 2: modulus = "minimal_weight" else: modulus = "random" elif modulus == "random": modulus += str(random.randint(0, 1 << 128)) if isinstance(modulus, (list, tuple)): modulus = FiniteField(p)["x"](modulus) # some classes use 'random' as the modulus to # generate a random modulus, but we don't want # to cache it elif sage.rings.polynomial.polynomial_element.is_Polynomial(modulus): modulus = modulus.change_variable_name("x") elif not isinstance(modulus, str): raise ValueError("Modulus parameter not understood.") else: # Neither a prime, nor a prime power raise ValueError("the order of a finite field must be a prime power.") return (order, name, modulus, impl, str(kwds), p, n, proof), kwds
def create_key_and_extra_args(self, order, name=None, modulus=None, names=None, impl=None, proof=None, **kwds): """ EXAMPLES:: sage: GF.create_key_and_extra_args(9, 'a') ((9, ('a',), x^2 + 2*x + 2, None, '{}', 3, 2, True), {}) sage: GF.create_key_and_extra_args(9, 'a', foo='value') ((9, ('a',), x^2 + 2*x + 2, None, "{'foo': 'value'}", 3, 2, True), {'foo': 'value'}) """ from sage.structure.proof.all import WithProof, arithmetic if proof is None: proof = arithmetic() with WithProof('arithmetic', proof): order = int(order) if order <= 1: raise ValueError("the order of a finite field must be > 1.") if arith.is_prime(order): name = None modulus = None p = integer.Integer(order) n = integer.Integer(1) elif arith.is_prime_power(order): if not names is None: name = names name = normalize_names(1, name) p, n = arith.factor(order)[0] if modulus is None or isinstance(modulus, str): # A string specifies an algorithm to find a suitable modulus. if modulus == "default": # for backward compatibility modulus = None modulus = GF(p)['x'].irreducible_element(n, algorithm=modulus) elif isinstance(modulus, (list, tuple)): modulus = GF(p)['x'](modulus) elif sage.rings.polynomial.polynomial_element.is_Polynomial( modulus): modulus = modulus.change_variable_name('x') else: raise TypeError("wrong type for modulus parameter") else: raise ValueError( "the order of a finite field must be a prime power.") return (order, name, modulus, impl, str(kwds), p, n, proof), kwds
def _single_variate(base_ring, name, sparse, implementation): import sage.rings.polynomial.polynomial_ring as m name = normalize_names(1, name) key = (base_ring, name, sparse, implementation if not sparse else None) R = _get_from_cache(key) if not R is None: return R if isinstance(base_ring, ring.CommutativeRing): if is_IntegerModRing(base_ring) and not sparse: n = base_ring.order() if n.is_prime(): R = m.PolynomialRing_dense_mod_p(base_ring, name, implementation=implementation) elif n > 1: R = m.PolynomialRing_dense_mod_n(base_ring, name, implementation=implementation) else: # n == 1! R = m.PolynomialRing_integral_domain(base_ring, name) # specialized code breaks in this case. elif is_FiniteField(base_ring) and not sparse: R = m.PolynomialRing_dense_finite_field(base_ring, name, implementation=implementation) elif isinstance(base_ring, padic_base_leaves.pAdicFieldCappedRelative): R = m.PolynomialRing_dense_padic_field_capped_relative(base_ring, name) elif isinstance(base_ring, padic_base_leaves.pAdicRingCappedRelative): R = m.PolynomialRing_dense_padic_ring_capped_relative(base_ring, name) elif isinstance(base_ring, padic_base_leaves.pAdicRingCappedAbsolute): R = m.PolynomialRing_dense_padic_ring_capped_absolute(base_ring, name) elif isinstance(base_ring, padic_base_leaves.pAdicRingFixedMod): R = m.PolynomialRing_dense_padic_ring_fixed_mod(base_ring, name) elif base_ring.is_field(proof=False): R = m.PolynomialRing_field(base_ring, name, sparse) elif base_ring.is_integral_domain(proof=False): R = m.PolynomialRing_integral_domain(base_ring, name, sparse, implementation) else: R = m.PolynomialRing_commutative(base_ring, name, sparse) else: R = m.PolynomialRing_general(base_ring, name, sparse) if hasattr(R, "_implementation_names"): for name in R._implementation_names: real_key = key[0:3] + (name,) _save_in_cache(real_key, R) else: _save_in_cache(key, R) return R
def FreeAbelianMonoid(index_set=None, names=None, **kwds): """ Return a free abelian monoid on `n` generators or with the generators indexed by a set `I`. We construct free abelian monoids by specifing either: - the number of generators and/or the names of the generators - the indexing set for the generators (this ignores the other two inputs) INPUT: - ``index_set`` -- an indexing set for the generators; if an integer, then this becomes `\{0, 1, \ldots, n-1\}` - ``names`` -- names of generators OUTPUT: A free abelian monoid. EXAMPLES:: sage: F.<a,b,c,d,e> = FreeAbelianMonoid(); F Free abelian monoid on 5 generators (a, b, c, d, e) sage: FreeAbelianMonoid(index_set=ZZ) Free abelian monoid indexed by Integer Ring """ if isinstance(index_set, str): # Swap args (this works if names is None as well) names, index_set = index_set, names if index_set is None and names is not None: if isinstance(names, str): index_set = names.count(',') else: index_set = len(names) if index_set not in ZZ: if names is not None: names = normalize_names(len(names), names) from sage.monoids.indexed_free_monoid import IndexedFreeAbelianMonoid return IndexedFreeAbelianMonoid(index_set, names=names, **kwds) if names is None: raise ValueError("names must be specified") return FreeAbelianMonoid_factory(index_set, names)
def FreeAbelianMonoid(index_set=None, names=None, **kwds): """ Return a free abelian monoid on `n` generators or with the generators indexed by a set `I`. We construct free abelian monoids by specifing either: - the number of generators and/or the names of the generators - the indexing set for the generators (this ignores the other two inputs) INPUT: - ``index_set`` -- an indexing set for the generators; if an integer, then this becomes `\{0, 1, \ldots, n-1\}` - ``names`` -- names of generators OUTPUT: A free abelian monoid. EXAMPLES:: sage: F.<a,b,c,d,e> = FreeAbelianMonoid(); F Free abelian monoid on 5 generators (a, b, c, d, e) sage: FreeAbelianMonoid(index_set=ZZ) Free abelian monoid indexed by Integer Ring """ if isinstance(index_set, str): # Swap args (this works if names is None as well) names, index_set = index_set, names if index_set is None and names is not None: if isinstance(names, str): index_set = names.count(',') else: index_set = len(names) if index_set not in ZZ: if names is not None: names = normalize_names(len(names), names) from sage.monoids.indexed_free_monoid import IndexedFreeAbelianMonoid return IndexedFreeAbelianMonoid(index_set, names=names, **kwds) if names is None: raise ValueError("names must be specified") return FreeAbelianMonoid_factory(index_set, names)
def _multi_variate(base_ring, names, n, sparse, order, implementation): # if not sparse: # raise ValueError, "A dense representation of multivariate polynomials is not supported" sparse = False # "True" would be correct, since there is no dense implementation of # multivariate polynomials. However, traditionally, "False" is used in the key, # even though it is meaningless. if implementation is not None: raise ValueError( "The %s implementation is not known for multivariate polynomial rings" % implementation) names = normalize_names(n, names) import sage.rings.polynomial.multi_polynomial_ring as m from sage.rings.polynomial.term_order import TermOrder order = TermOrder(order, n) key = (base_ring, names, n, sparse, order) R = _get_from_cache(key) if not R is None: return R from sage.rings.polynomial.multi_polynomial_libsingular import MPolynomialRing_libsingular if m.integral_domain.is_IntegralDomain(base_ring): if n < 1: R = m.MPolynomialRing_polydict_domain(base_ring, n, names, order) else: try: R = MPolynomialRing_libsingular(base_ring, n, names, order) except (TypeError, NotImplementedError): R = m.MPolynomialRing_polydict_domain(base_ring, n, names, order) else: if not base_ring.is_zero(): try: R = MPolynomialRing_libsingular(base_ring, n, names, order) except (TypeError, NotImplementedError): R = m.MPolynomialRing_polydict(base_ring, n, names, order) else: R = m.MPolynomialRing_polydict(base_ring, n, names, order) _save_in_cache(key, R) return R
def _multi_variate(base_ring, names, n, sparse, order, implementation): # if not sparse: # raise ValueError, "A dense representation of multivariate polynomials is not supported" sparse = False # "True" would be correct, since there is no dense implementation of # multivariate polynomials. However, traditionally, "False" is used in the key, # even though it is meaningless. if implementation is not None: raise ValueError("The %s implementation is not known for multivariate polynomial rings" % implementation) names = normalize_names(n, names) import sage.rings.polynomial.multi_polynomial_ring as m from sage.rings.polynomial.term_order import TermOrder order = TermOrder(order, n) key = (base_ring, names, n, sparse, order) R = _get_from_cache(key) if not R is None: return R from sage.rings.polynomial.multi_polynomial_libsingular import MPolynomialRing_libsingular if m.integral_domain.is_IntegralDomain(base_ring): if n < 1: R = m.MPolynomialRing_polydict_domain(base_ring, n, names, order) else: try: R = MPolynomialRing_libsingular(base_ring, n, names, order) except (TypeError, NotImplementedError): R = m.MPolynomialRing_polydict_domain(base_ring, n, names, order) else: if not base_ring.is_zero(): try: R = MPolynomialRing_libsingular(base_ring, n, names, order) except (TypeError, NotImplementedError): R = m.MPolynomialRing_polydict(base_ring, n, names, order) else: R = m.MPolynomialRing_polydict(base_ring, n, names, order) _save_in_cache(key, R) return R
def create_key_and_extra_args(self, order, name=None, modulus=None, names=None, impl=None, proof=None, **kwds): """ EXAMPLES:: sage: GF.create_key_and_extra_args(9, 'a') ((9, ('a',), x^2 + 2*x + 2, None, '{}', 3, 2, True), {}) sage: GF.create_key_and_extra_args(9, 'a', foo='value') ((9, ('a',), x^2 + 2*x + 2, None, "{'foo': 'value'}", 3, 2, True), {'foo': 'value'}) """ from sage.structure.proof.all import WithProof, arithmetic if proof is None: proof = arithmetic() with WithProof('arithmetic', proof): order = int(order) if order <= 1: raise ValueError("the order of a finite field must be > 1.") if arith.is_prime(order): name = None modulus = None p = integer.Integer(order) n = integer.Integer(1) elif arith.is_prime_power(order): if not names is None: name = names name = normalize_names(1,name) p, n = arith.factor(order)[0] if modulus is None or isinstance(modulus, str): # A string specifies an algorithm to find a suitable modulus. if modulus == "default": # for backward compatibility modulus = None modulus = GF(p)['x'].irreducible_element(n, algorithm=modulus) elif isinstance(modulus, (list, tuple)): modulus = GF(p)['x'](modulus) elif sage.rings.polynomial.polynomial_element.is_Polynomial(modulus): modulus = modulus.change_variable_name('x') else: raise TypeError("wrong type for modulus parameter") else: raise ValueError("the order of a finite field must be a prime power.") return (order, name, modulus, impl, str(kwds), p, n, proof), kwds
def _multi_variate(base_ring, names, n, sparse, order): """ EXAMPLES:: sage: from sage.rings.polynomial.laurent_polynomial_ring import _multi_variate sage: _multi_variate(QQ, ('x','y'), 2, False, 'degrevlex') Multivariate Laurent Polynomial Ring in x, y over Rational Field """ # We need to come up with a name for the inverse that is easy to search # for in a string *and* doesn't overlap with the name that we already have. # For now, I'm going to use a name mangling with checking method. names = normalize_names(n, names) from term_order import TermOrder order = TermOrder(order, n) if isinstance(names, list): names = tuple(names) elif isinstance(names, str): if ',' in names: names = tuple(names.split(',')) key = (base_ring, names, n, sparse, order) P = _get_from_cache(key) if P is not None: return P prepend_string = "qk" while True: for a in names: if prepend_string in a: prepend_string += 'k' break else: break R = _multi_variate_poly(base_ring, names, n, sparse, order, None) P = LaurentPolynomialRing_mpair(R, prepend_string, names) _save_in_cache(key, P) return P
def _multi_variate(base_ring, names, n, sparse, order): """ EXAMPLES:: sage: from sage.rings.polynomial.laurent_polynomial_ring import _multi_variate sage: _multi_variate(QQ, ('x','y'), 2, False, 'degrevlex') Multivariate Laurent Polynomial Ring in x, y over Rational Field """ # We need to come up with a name for the inverse that is easy to search # for in a string *and* doesn't overlap with the name that we already have. # For now, I'm going to use a name mangling with checking method. names = normalize_names(n, names) from term_order import TermOrder order = TermOrder(order, n) if isinstance(names, list): names = tuple(names) elif isinstance(names, str): if ',' in names: names = tuple(names.split(',')) key = (base_ring, names, n, sparse, order) P = _get_from_cache(key) if P is not None: return P prepend_string = "qk" while True: for a in names: if prepend_string in a: prepend_string += 'k' break else: break R = _multi_variate_poly(base_ring, names, n, sparse, order, None) P = LaurentPolynomialRing_mpair(R, prepend_string, names) _save_in_cache(key, P) return P
def _single_variate(base_ring, names, sparse): """ EXAMPLES:: sage: from sage.rings.polynomial.laurent_polynomial_ring import _single_variate sage: _single_variate(QQ, ('x',), False) Univariate Laurent Polynomial Ring in x over Rational Field """ names = normalize_names(1, names) key = (base_ring, names, sparse) P = _get_from_cache(key) if P is not None: return P prepend_string = "qk" while True: if prepend_string in names: prepend_string += 'k' else: break R = _single_variate_poly(base_ring, names, sparse, None) P = LaurentPolynomialRing_univariate(R, names) _save_in_cache(key, P) return P
def _single_variate(base_ring, names, sparse): """ EXAMPLES:: sage: from sage.rings.polynomial.laurent_polynomial_ring import _single_variate sage: _single_variate(QQ, ('x',), False) Univariate Laurent Polynomial Ring in x over Rational Field """ names = normalize_names(1, names) key = (base_ring, names, sparse) P = _get_from_cache(key) if P is not None: return P prepend_string = "qk" while True: if prepend_string in names: prepend_string += 'k' else: break R = _single_variate_poly(base_ring, names, sparse, None) P = LaurentPolynomialRing_univariate(R, names) _save_in_cache(key, P) return P
def create_key_and_extra_args(self, order, name=None, modulus=None, names=None, impl=None, proof=None, check_irreducible=True, **kwds): """ EXAMPLES:: sage: GF.create_key_and_extra_args(9, 'a') ((9, ('a',), x^2 + 2*x + 2, 'givaro', '{}', 3, 2, True), {}) sage: GF.create_key_and_extra_args(9, 'a', foo='value') ((9, ('a',), x^2 + 2*x + 2, 'givaro', "{'foo': 'value'}", 3, 2, True), {'foo': 'value'}) """ import sage.rings.arith from sage.structure.proof.all import WithProof, arithmetic if proof is None: proof = arithmetic() with WithProof('arithmetic', proof): order = Integer(order) if order <= 1: raise ValueError("the order of a finite field must be at least 2") if order.is_prime(): p = order n = Integer(1) if impl is None: impl = 'modn' name = ('x',) # Ignore name # Every polynomial of degree 1 is irreducible check_irreducible = False # This check should be replaced by order.is_prime_power() # if Trac #16878 is fixed. elif sage.rings.arith.is_prime_power(order): if not names is None: name = names name = normalize_names(1,name) p, n = order.factor()[0] # The following is a temporary solution that allows us # to construct compatible systems of finite fields # until algebraic closures of finite fields are # implemented in Sage. It requires the user to # specify two parameters: # # - `conway` -- boolean; if True, this field is # constructed to fit in a compatible system using # a Conway polynomial. # - `prefix` -- a string used to generate names for # automatically constructed finite fields # # See the docstring of FiniteFieldFactory for examples. # # Once algebraic closures of finite fields are # implemented, this syntax should be superseded by # something like the following: # # sage: Fpbar = GF(5).algebraic_closure('z') # sage: F, e = Fpbar.subfield(3) # e is the embedding into Fpbar # sage: F # Finite field in z3 of size 5^3 # # This temporary solution only uses actual Conway # polynomials (no pseudo-Conway polynomials), since # pseudo-Conway polynomials are not unique, and until # we have algebraic closures of finite fields, there # is no good place to store a specific choice of # pseudo-Conway polynomials. if name is None: if not ('conway' in kwds and kwds['conway']): raise ValueError("parameter 'conway' is required if no name given") if 'prefix' not in kwds: raise ValueError("parameter 'prefix' is required if no name given") name = kwds['prefix'] + str(n) if 'conway' in kwds and kwds['conway']: from conway_polynomials import conway_polynomial if 'prefix' not in kwds: raise ValueError("a prefix must be specified if conway=True") if modulus is not None: raise ValueError("no modulus may be specified if conway=True") # The following raises a RuntimeError if no polynomial is found. modulus = conway_polynomial(p, n) if impl is None: if order < zech_log_bound: impl = 'givaro' elif p == 2: impl = 'ntl' else: impl = 'pari_ffelt' else: raise ValueError("the order of a finite field must be a prime power") # Determine modulus. # For the 'modn' implementation, we use the following # optimization which we also need to avoid an infinite loop: # a modulus of None is a shorthand for x-1. if modulus is not None or impl != 'modn': R = PolynomialRing(FiniteField(p), 'x') if modulus is None: modulus = R.irreducible_element(n) if isinstance(modulus, str): # A string specifies an algorithm to find a suitable modulus. if modulus == "default": from sage.misc.superseded import deprecation deprecation(16983, "the modulus 'default' is deprecated, use modulus=None instead (which is the default)") modulus = None modulus = R.irreducible_element(n, algorithm=modulus) else: if sage.rings.polynomial.polynomial_element.is_Polynomial(modulus): modulus = modulus.change_variable_name('x') modulus = R(modulus).monic() if modulus.degree() != n: raise ValueError("the degree of the modulus does not equal the degree of the field") if check_irreducible and not modulus.is_irreducible(): raise ValueError("finite field modulus must be irreducible but it is not") # If modulus is x - 1 for impl="modn", set it to None if impl == 'modn' and modulus[0] == -1: modulus = None return (order, name, modulus, impl, str(kwds), p, n, proof), kwds
def ProductProjectiveSpaces(n, R=None, names='x'): r""" Returns the cartesian product of projective spaces. Can input either a list of projective spaces over the same base ring or the list of dimensions, the base ring, and the variable names. INPUT: - ``n`` -- a list of integers or a list of projective spaces - ``R`` -- a ring - ``names`` -- a string or list of strings EXAMPLES:: sage: P1 = ProjectiveSpace(QQ,2,'x') sage: P2 = ProjectiveSpace(QQ,3,'y') sage: ProductProjectiveSpaces([P1,P2]) Product of projective spaces P^2 x P^3 over Rational Field :: sage: ProductProjectiveSpaces([2,2],GF(7),'y') Product of projective spaces P^2 x P^2 over Finite Field of size 7 :: sage: P1 = ProjectiveSpace(ZZ,2,'x') sage: P2 = ProjectiveSpace(QQ,3,'y') sage: ProductProjectiveSpaces([P1,P2]) Traceback (most recent call last): ... AttributeError: Components must be over the same base ring """ if isinstance(R, (list, tuple)): n, R = R, n if not isinstance(n, (tuple, list)): raise TypeError("Must be a list of dimensions") if R is None: R = QQ # default is the rationals if isinstance(n[0], ProjectiveSpace_ring): #this should be a list of projective spaces names = [] N = [] R = None for PS in n: if not isinstance(PS,ProjectiveSpace_ring): raise TypeError("Must be a list of Projective Spaces or (dimensions,base ring,names)") if R is None: R = PS.base_ring() elif R != PS.base_ring(): raise AttributeError("Components must be over the same base ring") N.append(PS.dimension_relative()) names += PS.variable_names() X = ProductProjectiveSpaces_ring(N, R, names) X._components = n else: if isinstance(R, (list,tuple)): n, R = R, n if not isinstance(n,(list,tuple)): raise ValueError("Need list or tuple of dimensions") if not is_CommutativeRing(R): raise ValueError("Must be a commutative ring") from sage.structure.parent_gens import normalize_names n_vars=sum(d+1 for d in n) if isinstance(names, six.string_types): names = normalize_names(n_vars, names) else: name_list = list(names) if len(name_list) == len(n): names = [] for name, dim in zip(name_list, n): names += normalize_names(dim+1, name) else: n_vars = sum(1+d for d in n) names = normalize_names(n_vars, name_list) X = ProductProjectiveSpaces_ring(n, R, names) return(X)
def create_key(self, n, names): n = int(n) names = normalize_names(n, names) return (n, names)
def BooleanPolynomialRing_constructor(n=None, names=None, order="lex"): """ Construct a boolean polynomial ring with the following parameters: INPUT: - ``n`` -- number of variables (an integer > 1) - ``names`` -- names of ring variables, may be a string or list/tuple of strings - ``order`` -- term order (default: lex) EXAMPLES:: sage: R.<x, y, z> = BooleanPolynomialRing() # indirect doctest sage: R Boolean PolynomialRing in x, y, z sage: p = x*y + x*z + y*z sage: x*p x*y*z + x*y + x*z sage: R.term_order() Lexicographic term order sage: R = BooleanPolynomialRing(5,'x',order='deglex(3),deglex(2)') sage: R.term_order() Block term order with blocks: (Degree lexicographic term order of length 3, Degree lexicographic term order of length 2) sage: R = BooleanPolynomialRing(3,'x',order='degrevlex') sage: R.term_order() Degree reverse lexicographic term order sage: BooleanPolynomialRing(names=('x','y')) Boolean PolynomialRing in x, y sage: BooleanPolynomialRing(names='x,y') Boolean PolynomialRing in x, y TESTS:: sage: P.<x,y> = BooleanPolynomialRing(2,order='degrevlex') sage: x > y True sage: P.<x0, x1, x2, x3> = BooleanPolynomialRing(4,order='degrevlex(2),degrevlex(2)') sage: x0 > x1 True sage: x2 > x3 True """ if isinstance(n, str): names = n n = 0 if n is None and names is not None: n = 0 names = normalize_names(n, names) if n is 0: n = len(names) from sage.rings.polynomial.term_order import TermOrder order = TermOrder(order, n) key = ("pbori", names, n, order) R = _get_from_cache(key) if not R is None: return R from sage.rings.polynomial.pbori import BooleanPolynomialRing R = BooleanPolynomialRing(n, names, order) _save_in_cache(key, R) return R
def create_key_and_extra_args(self, order, name=None, modulus=None, names=None, impl=None, proof=None, check_irreducible=True, **kwds): """ EXAMPLES:: sage: GF.create_key_and_extra_args(9, 'a') ((9, ('a',), x^2 + 2*x + 2, 'givaro', '{}', 3, 2, True), {}) sage: GF.create_key_and_extra_args(9, 'a', foo='value') ((9, ('a',), x^2 + 2*x + 2, 'givaro', "{'foo': 'value'}", 3, 2, True), {'foo': 'value'}) """ import sage.rings.arith from sage.structure.proof.all import WithProof, arithmetic if proof is None: proof = arithmetic() with WithProof('arithmetic', proof): order = Integer(order) if order <= 1: raise ValueError( "the order of a finite field must be at least 2") if order.is_prime(): p = order n = Integer(1) if impl is None: impl = 'modn' name = ('x', ) # Ignore name # Every polynomial of degree 1 is irreducible check_irreducible = False # This check should be replaced by order.is_prime_power() # if Trac #16878 is fixed. elif sage.rings.arith.is_prime_power(order): if not names is None: name = names name = normalize_names(1, name) p, n = order.factor()[0] # The following is a temporary solution that allows us # to construct compatible systems of finite fields # until algebraic closures of finite fields are # implemented in Sage. It requires the user to # specify two parameters: # # - `conway` -- boolean; if True, this field is # constructed to fit in a compatible system using # a Conway polynomial. # - `prefix` -- a string used to generate names for # automatically constructed finite fields # # See the docstring of FiniteFieldFactory for examples. # # Once algebraic closures of finite fields are # implemented, this syntax should be superseded by # something like the following: # # sage: Fpbar = GF(5).algebraic_closure('z') # sage: F, e = Fpbar.subfield(3) # e is the embedding into Fpbar # sage: F # Finite field in z3 of size 5^3 # # This temporary solution only uses actual Conway # polynomials (no pseudo-Conway polynomials), since # pseudo-Conway polynomials are not unique, and until # we have algebraic closures of finite fields, there # is no good place to store a specific choice of # pseudo-Conway polynomials. if name is None: if not ('conway' in kwds and kwds['conway']): raise ValueError( "parameter 'conway' is required if no name given") if 'prefix' not in kwds: raise ValueError( "parameter 'prefix' is required if no name given") name = kwds['prefix'] + str(n) if 'conway' in kwds and kwds['conway']: from conway_polynomials import conway_polynomial if 'prefix' not in kwds: raise ValueError( "a prefix must be specified if conway=True") if modulus is not None: raise ValueError( "no modulus may be specified if conway=True") # The following raises a RuntimeError if no polynomial is found. modulus = conway_polynomial(p, n) if impl is None: if order < zech_log_bound: impl = 'givaro' elif p == 2: impl = 'ntl' else: impl = 'pari_ffelt' else: raise ValueError( "the order of a finite field must be a prime power") # Determine modulus. # For the 'modn' implementation, we use the following # optimization which we also need to avoid an infinite loop: # a modulus of None is a shorthand for x-1. if modulus is not None or impl != 'modn': R = PolynomialRing(FiniteField(p), 'x') if modulus is None: modulus = R.irreducible_element(n) if isinstance(modulus, str): # A string specifies an algorithm to find a suitable modulus. if modulus == "default": from sage.misc.superseded import deprecation deprecation( 16983, "the modulus 'default' is deprecated, use modulus=None instead (which is the default)" ) modulus = None modulus = R.irreducible_element(n, algorithm=modulus) else: if sage.rings.polynomial.polynomial_element.is_Polynomial( modulus): modulus = modulus.change_variable_name('x') modulus = R(modulus).monic() if modulus.degree() != n: raise ValueError( "the degree of the modulus does not equal the degree of the field" ) if check_irreducible and not modulus.is_irreducible(): raise ValueError( "finite field modulus must be irreducible but it is not" ) # If modulus is x - 1 for impl="modn", set it to None if impl == 'modn' and modulus[0] == -1: modulus = None return (order, name, modulus, impl, str(kwds), p, n, proof), kwds
def PowerSeriesRing(base_ring, name=None, arg2=None, names=None, sparse=False, default_prec=None, order='negdeglex', num_gens=None): r""" Create a univariate or multivariate power series ring over a given (commutative) base ring. INPUT: - ``base_ring`` - a commutative ring - ``name``, ``names`` - name(s) of the indeterminate - ``default_prec`` - the default precision used if an exact object must be changed to an approximate object in order to do an arithmetic operation. If left as ``None``, it will be set to 20 in the univariate case, and 12 in the multivariate case. - ``sparse`` - (default: ``False``) whether power series are represented as sparse objects. - ``order`` - (default: ``negdeglex``) term ordering, for multivariate case - ``num_gens`` - number of generators, for multivariate case There is a unique power series ring over each base ring with given variable name. Two power series over the same base ring with different variable names are not equal or isomorphic. EXAMPLES (Univariate):: sage: R = PowerSeriesRing(QQ, 'x'); R Power Series Ring in x over Rational Field :: sage: S = PowerSeriesRing(QQ, 'y'); S Power Series Ring in y over Rational Field :: sage: R = PowerSeriesRing(QQ, 10) Traceback (most recent call last): ... ValueError: first letter of variable name must be a letter :: sage: S = PowerSeriesRing(QQ, 'x', default_prec = 15); S Power Series Ring in x over Rational Field sage: S.default_prec() 15 EXAMPLES (Multivariate) See also :doc:`multi_power_series_ring`:: sage: R = PowerSeriesRing(QQ, 't,u,v'); R Multivariate Power Series Ring in t, u, v over Rational Field :: sage: N = PowerSeriesRing(QQ,'w',num_gens=5); N Multivariate Power Series Ring in w0, w1, w2, w3, w4 over Rational Field Number of generators can be specified before variable name without using keyword:: sage: M = PowerSeriesRing(QQ,4,'k'); M Multivariate Power Series Ring in k0, k1, k2, k3 over Rational Field Multivariate power series can be constructed using angle bracket or double square bracket notation:: sage: R.<t,u,v> = PowerSeriesRing(QQ, 't,u,v'); R Multivariate Power Series Ring in t, u, v over Rational Field sage: ZZ[['s,t,u']] Multivariate Power Series Ring in s, t, u over Integer Ring Sparse multivariate power series ring:: sage: M = PowerSeriesRing(QQ,4,'k',sparse=True); M Sparse Multivariate Power Series Ring in k0, k1, k2, k3 over Rational Field Power series ring over polynomial ring:: sage: H = PowerSeriesRing(PolynomialRing(ZZ,3,'z'),4,'f'); H Multivariate Power Series Ring in f0, f1, f2, f3 over Multivariate Polynomial Ring in z0, z1, z2 over Integer Ring Power series ring over finite field:: sage: S = PowerSeriesRing(GF(65537),'x,y'); S Multivariate Power Series Ring in x, y over Finite Field of size 65537 Power series ring with many variables:: sage: R = PowerSeriesRing(ZZ, ['x%s'%p for p in primes(100)]); R Multivariate Power Series Ring in x2, x3, x5, x7, x11, x13, x17, x19, x23, x29, x31, x37, x41, x43, x47, x53, x59, x61, x67, x71, x73, x79, x83, x89, x97 over Integer Ring - Use :meth:`inject_variables` to make the variables available for interactive use. :: sage: R.inject_variables() Defining x2, x3, x5, x7, x11, x13, x17, x19, x23, x29, x31, x37, x41, x43, x47, x53, x59, x61, x67, x71, x73, x79, x83, x89, x97 sage: f = x47 + 3*x11*x29 - x19 + R.O(3) sage: f in R True Variable ordering determines how series are displayed:: sage: T.<a,b> = PowerSeriesRing(ZZ,order='deglex'); T Multivariate Power Series Ring in a, b over Integer Ring sage: T.term_order() Degree lexicographic term order sage: p = - 2*b^6 + a^5*b^2 + a^7 - b^2 - a*b^3 + T.O(9); p a^7 + a^5*b^2 - 2*b^6 - a*b^3 - b^2 + O(a, b)^9 sage: U = PowerSeriesRing(ZZ,'a,b',order='negdeglex'); U Multivariate Power Series Ring in a, b over Integer Ring sage: U.term_order() Negative degree lexicographic term order sage: U(p) -b^2 - a*b^3 - 2*b^6 + a^7 + a^5*b^2 + O(a, b)^9 TESTS:: sage: N = PowerSeriesRing(QQ,'k',num_gens=5); N Multivariate Power Series Ring in k0, k1, k2, k3, k4 over Rational Field The following behavior of univariate power series ring will eventually be deprecated and then changed to return a multivariate power series ring:: sage: N = PowerSeriesRing(QQ,'k',5); N Power Series Ring in k over Rational Field sage: N.default_prec() 5 sage: L.<m> = PowerSeriesRing(QQ,5); L Power Series Ring in m over Rational Field sage: L.default_prec() 5 """ #multivariate case: # examples for first case: # PowerSeriesRing(QQ,'x,y,z') # PowerSeriesRing(QQ,['x','y','z']) # PowerSeriesRing(QQ,['x','y','z'], 3) if names is None and name is not None: names = name if isinstance(names, (tuple, list)) and len(names) > 1 or (isinstance(names, str) and ',' in names): return _multi_variate(base_ring, num_gens=arg2, names=names, order=order, default_prec=default_prec, sparse=sparse) # examples for second case: # PowerSeriesRing(QQ,3,'t') if arg2 is None and num_gens is not None: arg2 = names names = num_gens if isinstance(arg2, str) and isinstance(names, (int,long,integer.Integer)): return _multi_variate(base_ring, num_gens=names, names=arg2, order=order, default_prec=default_prec, sparse=sparse) # univariate case: the arguments to PowerSeriesRing used to be # (base_ring, name=None, default_prec=20, names=None, sparse=False), # and thus that is what the code below expects; this behavior is being # deprecated, and will eventually be removed. if default_prec is None and arg2 is None: default_prec = 20 elif arg2 is not None: default_prec = arg2 ## too many things (padics, elliptic curves) depend on this behavior, ## so no warning for now. ## # from sage.misc.misc import deprecation # if isinstance(name, (int,long,integer.Integer)) or isinstance(arg2,(int,long,integer.Integer)): # deprecation("This behavior of PowerSeriesRing is being deprecated in favor of constructing multivariate power series rings. (See Trac ticket #1956.)") # the following is the original, univariate-only code if isinstance(name, (int,long,integer.Integer)): default_prec = name if not names is None: name = names try: name = gens.normalize_names(1, name) except TypeError: raise TypeError, "illegal variable name" if name is None: raise TypeError, "You must specify the name of the indeterminate of the Power series ring." key = (base_ring, name, default_prec, sparse) if _cache.has_key(key): R = _cache[key]() if not R is None: return R if isinstance(name, (tuple, list)): assert len(name) == 1 name = name[0] if not (name is None or isinstance(name, str)): raise TypeError, "variable name must be a string or None" if isinstance(base_ring, field.Field): R = PowerSeriesRing_over_field(base_ring, name, default_prec, sparse=sparse) elif isinstance(base_ring, integral_domain.IntegralDomain): R = PowerSeriesRing_domain(base_ring, name, default_prec, sparse=sparse) elif isinstance(base_ring, commutative_ring.CommutativeRing): R = PowerSeriesRing_generic(base_ring, name, default_prec, sparse=sparse) else: raise TypeError, "base_ring must be a commutative ring" _cache[key] = weakref.ref(R) return R
def BooleanPolynomialRing_constructor(n=None, names=None, order="lex"): """ Construct a boolean polynomial ring with the following parameters: INPUT: - ``n`` -- number of variables (an integer > 1) - ``names`` -- names of ring variables, may be a string or list/tuple of strings - ``order`` -- term order (default: lex) EXAMPLES:: sage: R.<x, y, z> = BooleanPolynomialRing() # indirect doctest sage: R Boolean PolynomialRing in x, y, z sage: p = x*y + x*z + y*z sage: x*p x*y*z + x*y + x*z sage: R.term_order() Lexicographic term order sage: R = BooleanPolynomialRing(5,'x',order='deglex(3),deglex(2)') sage: R.term_order() Block term order with blocks: (Degree lexicographic term order of length 3, Degree lexicographic term order of length 2) sage: R = BooleanPolynomialRing(3,'x',order='degneglex') sage: R.term_order() Degree negative lexicographic term order sage: BooleanPolynomialRing(names=('x','y')) Boolean PolynomialRing in x, y sage: BooleanPolynomialRing(names='x,y') Boolean PolynomialRing in x, y TESTS:: sage: P.<x,y> = BooleanPolynomialRing(2,order='deglex') sage: x > y True sage: P.<x0, x1, x2, x3> = BooleanPolynomialRing(4,order='deglex(2),deglex(2)') sage: x0 > x1 True sage: x2 > x3 True """ if isinstance(n, str): names = n n = 0 if n is None and names is not None: n = 0 names = normalize_names(n, names) if n is 0: n = len(names) from sage.rings.polynomial.term_order import TermOrder order = TermOrder(order, n) key = ("pbori", names, n, order) R = _get_from_cache(key) if not R is None: return R from sage.rings.polynomial.pbori import BooleanPolynomialRing R = BooleanPolynomialRing(n, names, order) _save_in_cache(key, R) return R
def FreeMonoid(index_set=None, names=None, commutative=False, **kwds): r""" Return a free monoid on `n` generators or with the generators indexed by a set `I`. We construct free monoids by specifing either: - the number of generators and/or the names of the generators - the indexing set for the generators INPUT: - ``index_set`` -- an indexing set for the generators; if an integer, than this becomes `\{0, 1, \ldots, n-1\}` - ``names`` -- names of generators - ``commutative`` -- (default: ``False``) whether the free monoid is commutative or not OUTPUT: A free monoid. EXAMPLES:: sage: F.<a,b,c,d,e> = FreeMonoid(); F Free monoid on 5 generators (a, b, c, d, e) sage: FreeMonoid(index_set=ZZ) Free monoid indexed by Integer Ring sage: F.<x,y,z> = FreeMonoid(abelian=True); F Free abelian monoid on 3 generators (x, y, z) sage: FreeMonoid(index_set=ZZ, commutative=True) Free abelian monoid indexed by Integer Ring """ if 'abelian' in kwds: commutative = kwds['abelian'] del kwds['abelian'] if commutative: from sage.monoids.free_abelian_monoid import FreeAbelianMonoid return FreeAbelianMonoid(index_set, names, **kwds) if isinstance(index_set, str): # Swap args (this works if names is None as well) names, index_set = index_set, names if index_set is None and names is not None: if isinstance(names, str): index_set = names.count(',') else: index_set = len(names) if index_set not in ZZ: if names is not None: names = normalize_names(len(names), names) from sage.monoids.indexed_free_monoid import IndexedFreeMonoid return IndexedFreeMonoid(index_set, names=names, **kwds) if names is None: raise ValueError("names must be specified") return FreeMonoid_factory(index_set, names)
def ProductProjectiveSpaces(n, R=None, names='x'): r""" Returns the cartesian product of projective spaces. Can input either a list of projective spaces over the same base ring or the list of dimensions, the base ring, and the variable names. INPUT: - ``n`` -- a list of integers or a list of projective spaces - ``R`` -- a ring - ``names`` -- a string or list of strings EXAMPLES:: sage: P1 = ProjectiveSpace(QQ,2,'x') sage: P2 = ProjectiveSpace(QQ,3,'y') sage: ProductProjectiveSpaces([P1,P2]) Product of projective spaces P^2 x P^3 over Rational Field :: sage: ProductProjectiveSpaces([2,2],GF(7),'y') Product of projective spaces P^2 x P^2 over Finite Field of size 7 :: sage: P1 = ProjectiveSpace(ZZ,2,'x') sage: P2 = ProjectiveSpace(QQ,3,'y') sage: ProductProjectiveSpaces([P1,P2]) Traceback (most recent call last): ... AttributeError: Components must be over the same base ring """ if isinstance(R, (list, tuple)): n, R = R, n if not isinstance(n, (tuple, list)): raise TypeError("Must be a list of dimensions") if R is None: R = QQ # default is the rationals if isinstance(n[0], ProjectiveSpace_ring): #this should be a list of projective spaces names = [] N = [] R = None for PS in n: if not isinstance(PS,ProjectiveSpace_ring): raise TypeError("Must be a list of Projective Spaces or (dimensions,base ring,names)") if R is None: R = PS.base_ring() elif R != PS.base_ring(): raise AttributeError("Components must be over the same base ring") N.append(PS.dimension_relative()) names += PS.variable_names() X = ProductProjectiveSpaces_ring(N, R, names) X._components = n else: if isinstance(R, (list,tuple)): n, R = R, n if not isinstance(n,(list,tuple)): raise ValueError("Need list or tuple of dimensions") if not is_CommutativeRing(R): raise ValueError("Must be a commutative ring") from sage.structure.parent_gens import normalize_names n_vars=sum(d+1 for d in n) if isinstance(names, basestring): names = normalize_names(n_vars, names) else: name_list = list(names) if len(name_list) == len(n): names = [] for name, dim in zip(name_list, n): names += normalize_names(dim+1, name) else: n_vars = sum(1+d for d in n) names = normalize_names(n_vars, name_list) X = ProductProjectiveSpaces_ring(n, R, names) return(X)
def create_key_and_extra_args(self, order, name=None, modulus=None, names=None, impl=None, proof=None, **kwds): """ EXAMPLES:: sage: GF.create_key_and_extra_args(9, 'a') ((9, ('a',), x^2 + 2*x + 2, None, '{}', 3, 2, True), {}) sage: GF.create_key_and_extra_args(9, 'a', foo='value') ((9, ('a',), x^2 + 2*x + 2, None, "{'foo': 'value'}", 3, 2, True), {'foo': 'value'}) """ from sage.structure.proof.all import WithProof, arithmetic if proof is None: proof = arithmetic() with WithProof('arithmetic', proof): order = int(order) if order <= 1: raise ValueError("the order of a finite field must be > 1.") if arith.is_prime(order): name = None modulus = None p = integer.Integer(order) n = integer.Integer(1) elif arith.is_prime_power(order): if not names is None: name = names name = normalize_names(1, name) p, n = arith.factor(order)[0] # The following is a temporary solution that allows us # to construct compatible systems of finite fields # until algebraic closures of finite fields are # implemented in Sage. It requires the user to # specify two parameters: # # - `conway` -- boolean; if True, this field is # constructed to fit in a compatible system using # a Conway polynomial. # - `prefix` -- a string used to generate names for # automatically constructed finite fields # # See the docstring of FiniteFieldFactory for examples. # # Once algebraic closures of finite fields are # implemented, this syntax should be superseded by # something like the following: # # sage: Fpbar = GF(5).algebraic_closure('z') # sage: F, e = Fpbar.subfield(3) # e is the embedding into Fpbar # sage: F # Finite field in z3 of size 5^3 # # This temporary solution only uses actual Conway # polynomials (no pseudo-Conway polynomials), since # pseudo-Conway polynomials are not unique, and until # we have algebraic closures of finite fields, there # is no good place to store a specific choice of # pseudo-Conway polynomials. if name is None: if not (kwds.has_key('conway') and kwds['conway']): raise ValueError( "parameter 'conway' is required if no name given") if not kwds.has_key('prefix'): raise ValueError( "parameter 'prefix' is required if no name given") name = kwds['prefix'] + str(n) if kwds.has_key('conway') and kwds['conway']: from conway_polynomials import conway_polynomial if not kwds.has_key('prefix'): raise ValueError( "a prefix must be specified if conway=True") if modulus is not None: raise ValueError( "no modulus may be specified if conway=True") # The following raises a RuntimeError if no polynomial is found. modulus = conway_polynomial(p, n) if modulus is None or isinstance(modulus, str): # A string specifies an algorithm to find a suitable modulus. if modulus == "default": # for backward compatibility modulus = None modulus = GF(p)['x'].irreducible_element(n, algorithm=modulus) elif isinstance(modulus, (list, tuple)): modulus = GF(p)['x'](modulus) elif sage.rings.polynomial.polynomial_element.is_Polynomial( modulus): modulus = modulus.change_variable_name('x') else: raise TypeError("wrong type for modulus parameter") else: raise ValueError( "the order of a finite field must be a prime power.") return (order, name, modulus, impl, str(kwds), p, n, proof), kwds
def FreeMonoid(index_set=None, names=None, commutative=False, **kwds): r""" Return a free monoid on `n` generators or with the generators indexed by a set `I`. We construct free monoids by specifing either: - the number of generators and/or the names of the generators - the indexing set for the generators INPUT: - ``index_set`` -- an indexing set for the generators; if an integer, than this becomes `\{0, 1, \ldots, n-1\}` - ``names`` -- names of generators - ``commutative`` -- (default: ``False``) whether the free monoid is commutative or not OUTPUT: A free monoid. EXAMPLES:: sage: F.<a,b,c,d,e> = FreeMonoid(); F Free monoid on 5 generators (a, b, c, d, e) sage: FreeMonoid(index_set=ZZ) Free monoid indexed by Integer Ring sage: F.<x,y,z> = FreeMonoid(abelian=True); F Free abelian monoid on 3 generators (x, y, z) sage: FreeMonoid(index_set=ZZ, commutative=True) Free abelian monoid indexed by Integer Ring """ if 'abelian' in kwds: commutative = kwds['abelian'] del kwds['abelian'] if commutative: from sage.monoids.free_abelian_monoid import FreeAbelianMonoid return FreeAbelianMonoid(index_set, names, **kwds) if isinstance(index_set, str): # Swap args (this works if names is None as well) names, index_set = index_set, names if index_set is None and names is not None: if isinstance(names, str): index_set = names.count(',') else: index_set = len(names) if index_set not in ZZ: if names is not None: names = normalize_names(len(names), names) from sage.monoids.indexed_free_monoid import IndexedFreeMonoid return IndexedFreeMonoid(index_set, names=names, **kwds) if names is None: raise ValueError("names must be specified") return FreeMonoid_factory(index_set, names)
def create_key(self, n, names): n = int(n) names = normalize_names(n, names) return (n, names)
def create_key_and_extra_args(self, order, name=None, modulus=None, names=None, impl=None, proof=None, **kwds): """ EXAMPLES:: sage: GF.create_key_and_extra_args(9, 'a') ((9, ('a',), x^2 + 2*x + 2, None, '{}', 3, 2, True), {}) sage: GF.create_key_and_extra_args(9, 'a', foo='value') ((9, ('a',), x^2 + 2*x + 2, None, "{'foo': 'value'}", 3, 2, True), {'foo': 'value'}) """ from sage.structure.proof.all import WithProof, arithmetic if proof is None: proof = arithmetic() with WithProof('arithmetic', proof): order = int(order) if order <= 1: raise ValueError("the order of a finite field must be > 1.") if arith.is_prime(order): name = None modulus = None p = integer.Integer(order) n = integer.Integer(1) elif arith.is_prime_power(order): if not names is None: name = names name = normalize_names(1,name) p, n = arith.factor(order)[0] # The following is a temporary solution that allows us # to construct compatible systems of finite fields # until algebraic closures of finite fields are # implemented in Sage. It requires the user to # specify two parameters: # # - `conway` -- boolean; if True, this field is # constructed to fit in a compatible system using # a Conway polynomial. # - `prefix` -- a string used to generate names for # automatically constructed finite fields # # See the docstring of FiniteFieldFactory for examples. # # Once algebraic closures of finite fields are # implemented, this syntax should be superseded by # something like the following: # # sage: Fpbar = GF(5).algebraic_closure('z') # sage: F, e = Fpbar.subfield(3) # e is the embedding into Fpbar # sage: F # Finite field in z3 of size 5^3 # # This temporary solution only uses actual Conway # polynomials (no pseudo-Conway polynomials), since # pseudo-Conway polynomials are not unique, and until # we have algebraic closures of finite fields, there # is no good place to store a specific choice of # pseudo-Conway polynomials. if name is None: if not (kwds.has_key('conway') and kwds['conway']): raise ValueError("parameter 'conway' is required if no name given") if not kwds.has_key('prefix'): raise ValueError("parameter 'prefix' is required if no name given") name = kwds['prefix'] + str(n) if kwds.has_key('conway') and kwds['conway']: from conway_polynomials import conway_polynomial if not kwds.has_key('prefix'): raise ValueError("a prefix must be specified if conway=True") if modulus is not None: raise ValueError("no modulus may be specified if conway=True") # The following raises a RuntimeError if no polynomial is found. modulus = conway_polynomial(p, n) if modulus is None or isinstance(modulus, str): # A string specifies an algorithm to find a suitable modulus. if modulus == "default": # for backward compatibility modulus = None modulus = GF(p)['x'].irreducible_element(n, algorithm=modulus) elif isinstance(modulus, (list, tuple)): modulus = GF(p)['x'](modulus) elif sage.rings.polynomial.polynomial_element.is_Polynomial(modulus): modulus = modulus.change_variable_name('x') else: raise TypeError("wrong type for modulus parameter") else: raise ValueError("the order of a finite field must be a prime power.") return (order, name, modulus, impl, str(kwds), p, n, proof), kwds