"""
if name == "_Sequence_generic__cr" and hasattr(self, "_Sequence__cr"):
self.__cr = self._Sequence__cr
return self.__cr
elif name == "_Sequence_generic__cr_str" and hasattr(
self, "_Sequence__cr_str"):
self.__cr_str = self._Sequence__cr_str
return self.__cr_str
elif name == "_Sequence_generic__immutable" and hasattr(
self, "_Sequence__immutable"):
self.__immutable = self._Sequence__immutable
return self.__immutable
elif name == "_Sequence_generic__universe" and hasattr(
self, "_Sequence__universe"):
self.__universe = self._Sequence__universe
return self.__universe
elif name == "_Sequence_generic__hash" and hasattr(
self, "_Sequence__hash"):
self.__hash = self._Sequence__hash
return self.__hash
else:
raise AttributeError(
"'Sequence_generic' object has no attribute '%s'" % name)
seq = Sequence
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.structure.sequence', 'Sequence',
Sequence_generic)
EXAMPLES::
sage: s = SymmetricFunctions(QQ).s()
sage: a = s([2,1])
sage: a.expand(2)
x0^2*x1 + x0*x1^2
sage: a.expand(3)
x0^2*x1 + x0*x1^2 + x0^2*x2 + 2*x0*x1*x2 + x1^2*x2 + x0*x2^2 + x1*x2^2
sage: a.expand(4)
x0^2*x1 + x0*x1^2 + x0^2*x2 + 2*x0*x1*x2 + x1^2*x2 + x0*x2^2 + x1*x2^2 + x0^2*x3 + 2*x0*x1*x3 + x1^2*x3 + 2*x0*x2*x3 + 2*x1*x2*x3 + x2^2*x3 + x0*x3^2 + x1*x3^2 + x2*x3^2
sage: a.expand(2, alphabet='y')
y0^2*y1 + y0*y1^2
sage: a.expand(2, alphabet=['a','b'])
a^2*b + a*b^2
sage: s([1,1,1,1]).expand(3)
0
sage: (s([]) + 2*s([1])).expand(3)
2*x0 + 2*x1 + 2*x2 + 1
sage: s([1]).expand(0)
0
sage: (3*s([])).expand(0)
3
"""
condition = lambda part: len(part) > n
return self._expand(condition, n, alphabet)
# Backward compatibility for unpickling
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.combinat.sf.schur', 'SymmetricFunctionAlgebraElement_schur', SymmetricFunctionAlgebra_schur.Element)
"""
x = [self.mset.index(_) for _ in x]
return rank(x, len(self.mset))
##########################################################
# Deprecations
class ChooseNK(Combinations_setk):
def __setstate__(self, state):
r"""
For unpickling old ``ChooseNK`` objects.
TESTS::
sage: loads("x\x9ck`J.NLO\xd5K\xce\xcfM\xca\xccK,\xd1K\xce\xc8\xcf"
....: "/N\x8d\xcf\xcb\xe6r\x06\xb3\xfc\xbc\xb9\n\x195\x1b\x0b"
....: "\x99j\x0b\x995B\x99\xe2\xf3\nY :\x8a2\xf3\xd2\x8b\xf52"
....: "\xf3JR\xd3S\x8b\xb8r\x13\xb3S\xe3a\x9cB\xd6PF\xd3\xd6\xa0"
....: "B6\xa0\xfa\xecB\xf6\x0c \xd7\x08\xc8\xe5(M\xd2\x03\x00{"
....: "\x82$\xd8")
Combinations of [0, 1, 2, 3, 4] of length 2
"""
self.__class__ = Combinations_setk
Combinations_setk.__init__(self, range(state['_n']), state['_k'])
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override("sage.combinat.choose_nk", "ChooseNK", ChooseNK)
doctest:...: DeprecationWarning: OrderedAlphabet is deprecated; use Alphabet instead.
See http://trac.sagemath.org/8920 for details.
sage: O._alphabet = ['a', 'b']
sage: O._elements
('a', 'b')
"""
if name == '_elements':
if not hasattr(self, '_alphabet'):
raise AttributeError("no attribute '_elements'")
self._elements = tuple(self._alphabet)
from sage.structure.parent import Parent
from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets
Parent.__init__(self, category=FiniteEnumeratedSets(), facade=True)
return self._elements
raise AttributeError("no attribute %s"%name)
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override(
'sage.combinat.words.alphabet',
'OrderedAlphabet_NaturalNumbers',
NonNegativeIntegers,
call_name=('sage.sets.non_negative_integers', 'NonNegativeIntegers'))
register_unpickle_override(
'sage.combinat.words.alphabet',
'OrderedAlphabet_PositiveIntegers',
PositiveIntegers,
call_name=('sage.sets.positive_integers', 'PositiveIntegers'))
from __future__ import absolute_import
from .chain_complex import ChainComplex
from .chain_complex_morphism import ChainComplexMorphism
from .simplicial_complex import SimplicialComplex, Simplex
from .simplicial_complex_morphism import SimplicialComplexMorphism
from .delta_complex import DeltaComplex, delta_complexes
from .cubical_complex import CubicalComplex, cubical_complexes
from sage.misc.lazy_import import lazy_import
lazy_import('sage.homology.koszul_complex', 'KoszulComplex')
lazy_import('sage.homology', 'simplicial_complexes_catalog', 'simplicial_complexes')
lazy_import('sage.homology', 'simplicial_set_catalog', 'simplicial_sets')
# For taking care of old pickles
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.homology.examples', 'SimplicialSurface', SimplicialComplex)
- ``n`` -- a positive integer
- ``alphabet`` -- a variable for the expansion (default: `x`)
OUTPUT:
- a monomial expansion of an instance of dual of ``self`` in `n` variable
EXAMPLES::
sage: m = SymmetricFunctions(QQ).monomial()
sage: zee = sage.combinat.sf.sfa.zee
sage: h = m.dual_basis(zee)
sage: a = h([2,1])+h([3])
sage: a.expand(2)
2*x0^3 + 3*x0^2*x1 + 3*x0*x1^2 + 2*x1^3
sage: a.dual().expand(2)
2*x0^3 + 3*x0^2*x1 + 3*x0*x1^2 + 2*x1^3
sage: a.expand(2,alphabet='y')
2*y0^3 + 3*y0^2*y1 + 3*y0*y1^2 + 2*y1^3
sage: a.expand(2,alphabet='x,y')
2*x^3 + 3*x^2*y + 3*x*y^2 + 2*y^3
"""
return self._dual.expand(n, alphabet)
# Backward compatibility for unpickling
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.combinat.sf.dual',
'SymmetricFunctionAlgebraElement_dual',
SymmetricFunctionAlgebra_dual.Element)
C1
sage: sorted(b.edges())
[]
"""
return self.dual().dynkin_diagram().dual()
def ascii_art(self, label = lambda x: x):
"""
Returns a ascii art representation of the extended Dynkin diagram
EXAMPLES::
sage: print CartanType(['C',1]).ascii_art()
O
1
sage: print CartanType(['C',2]).ascii_art()
O=<=O
1 2
sage: print CartanType(['C',3]).ascii_art()
O---O=<=O
1 2 3
sage: print CartanType(['C',5]).ascii_art(label = lambda x: x+2)
O---O---O---O=<=O
3 4 5 6 7
"""
return self.dual().ascii_art(label = label).replace("=>=", "=<=")
# For unpickling backward compatibility (Sage <= 4.1)
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.combinat.root_system.type_C', 'ambient_space', AmbientSpace)
- a monomial expansion of an instance of ``self`` in `n` variables
EXAMPLES::
sage: e = SymmetricFunctions(QQ).e()
sage: e([2,1]).expand(3)
x0^2*x1 + x0*x1^2 + x0^2*x2 + 3*x0*x1*x2 + x1^2*x2 + x0*x2^2 + x1*x2^2
sage: e([1,1,1]).expand(2)
x0^3 + 3*x0^2*x1 + 3*x0*x1^2 + x1^3
sage: e([3]).expand(2)
0
sage: e([2]).expand(3)
x0*x1 + x0*x2 + x1*x2
sage: e([3]).expand(4,alphabet='x,y,z,t')
x*y*z + x*y*t + x*z*t + y*z*t
sage: e([3]).expand(4,alphabet='y')
y0*y1*y2 + y0*y1*y3 + y0*y2*y3 + y1*y2*y3
sage: e([]).expand(2)
1
"""
condition = lambda part: max(part) > n
return self._expand(condition, n, alphabet)
# Backward compatibility for unpickling
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.combinat.sf.elementary',
'SymmetricFunctionAlgebraElement_elementary',
SymmetricFunctionAlgebra_elementary.Element)
yield cur + [zero] * (len(l) - len(cur))
elif cur[-1] < zero or rem < zero:
rem += cur.pop() * l[k]
k -= 1
elif len(l) == len(cur) + 1:
if rem % l[-1] == zero:
yield cur + [rem // l[-1]]
else:
k += 1
cur.append(rem // l[k] + one)
rem -= cur[-1] * l[k]
def WeightedIntegerVectors_nweight(n, weight):
"""
Deprecated in :trac:`12453`. Use :class:`WeightedIntegerVectors` instead.
EXAMPLES::
sage: sage.combinat.integer_vector_weighted.WeightedIntegerVectors_nweight(7, [2,2])
doctest:...: DeprecationWarning: this class is deprecated. Use WeightedIntegerVectors instead
See http://trac.sagemath.org/12453 for details.
Integer vectors of 7 weighted by [2, 2]
"""
from sage.misc.superseded import deprecation
deprecation(12453, 'this class is deprecated. Use WeightedIntegerVectors instead')
return WeightedIntegerVectors(n, weight)
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.combinat.integer_vector_weighted', 'WeightedIntegerVectors_nweight', WeightedIntegerVectors)
INPUT:
- ``R`` -- a ring.
EXAMPLES::
sage: E = EllipticCurve('37a')
sage: Hom = E.point_homset(); Hom
Abelian group of points on Elliptic Curve defined
by y^2 + y = x^3 - x over Rational Field
sage: Hom.base_ring()
Integer Ring
sage: Hom.base_extend(QQ)
Traceback (most recent call last):
...
NotImplementedError: Abelian variety point sets are not
implemented as modules over rings other than ZZ.
"""
if R is not ZZ:
raise NotImplementedError('Abelian variety point sets are not '
'implemented as modules over rings other than ZZ.')
return self
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.schemes.generic.homset',
'SchemeHomsetModule_abelian_variety_coordinates_field',
SchemeHomset_points_abelian_variety_field)
sage: from sage.schemes.generic.spec import SpecFunctor
sage: F = SpecFunctor(GF(7))
sage: A.<x, y> = GF(7)[]
sage: B.<t> = GF(7)[]
sage: f = A.hom((t^2, t^3))
sage: Spec(f) # indirect doctest
Affine Scheme morphism:
From: Spectrum of Univariate Polynomial Ring in t over Finite Field of size 7
To: Spectrum of Multivariate Polynomial Ring in x, y over Finite Field of size 7
Defn: Ring morphism:
From: Multivariate Polynomial Ring in x, y over Finite Field of size 7
To: Univariate Polynomial Ring in t over Finite Field of size 7
Defn: x |--> t^2
y |--> t^3
"""
A = f.domain()
B = f.codomain()
return self(B).hom(f, self(A))
SpecZ = Spec(ZZ)
# Compatibility with older versions of this module
from sage.misc.superseded import deprecated_function_alias
is_Spec = deprecated_function_alias(16158, is_AffineScheme)
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.schemes.generic.spec', 'Spec', AffineScheme)
def unpickle_PolynomialRing(base_ring, arg1=None, arg2=None, sparse=False):
"""
Custom unpickling function for polynomial rings.
This has the same positional arguments as the old
``PolynomialRing`` constructor before :trac:`23338`.
"""
args = [arg for arg in (arg1, arg2) if arg is not None]
return PolynomialRing(base_ring, *args, sparse=sparse)
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.rings.polynomial.polynomial_ring_constructor',
'PolynomialRing', unpickle_PolynomialRing)
def _get_from_cache(key):
try:
return _cache[key]
except TypeError as msg:
raise TypeError('key = %s\n%s' % (key, msg))
except KeyError:
return None
def _save_in_cache(key, R):
try:
_cache[key] = R
except TypeError as msg:
There is no coercion for additive groups since ``+`` could mean
both the action (i.e., the group operation) or adding a term::
sage: G = groups.misc.AdditiveCyclic(3)
sage: ZG = G.algebra(ZZ, category=AdditiveMagmas())
sage: ZG.has_coerce_map_from(G)
False
"""
G = self.basis().keys()
K = self.base_ring()
if G.has_coerce_map_from(S):
from sage.categories.groups import Groups
# No coercion for additive groups because of ambiguity of +
# being the group action or addition of a new term.
return self.category().is_subcategory(Groups().Algebras(K))
if S in Sets.Algebras:
S_K = S.base_ring()
S_G = S.basis().keys()
hom_K = K.coerce_map_from(S_K)
hom_G = G.coerce_map_from(S_G)
if hom_K is not None and hom_G is not None:
return SetMorphism(S.Hom(self, category=self.category() | S.category()),
lambda x: self.sum_of_terms( (hom_G(g), hom_K(c)) for g,c in x ))
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.algebras.group_algebras', 'GroupAlgebra', GroupAlgebra_class)
sage: FormalSums(QQ).an_element()
1/2*1
sage: QQ.an_element()
1/2
"""
return FormalSum([(self.base_ring().an_element(), 1)],
check=check, reduce=reduce, parent=self)
formal_sums = FormalSums()
# Formal sums now derives from UniqueRepresentation, which makes the
# factory function unnecessary. This is why the name was changed from
# class FormalSums_generic to class FormalSums.
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.structure.formal_sum', 'FormalSums_generic', FormalSums)
class FormalSum(ModuleElement):
"""
A formal sum over a ring.
"""
def __init__(self, x, parent=formal_sums, check=True, reduce=True):
"""
INPUT:
- ``x`` -- object
- ``parent`` -- FormalSums(R) module (default: FormalSums(ZZ))
- ``check`` -- bool (default: True) if False, might not coerce
coefficients into base ring, which can speed
up constructing a formal sum.
- ``reduce`` -- reduce (default: True) if False, do not
"""
for p in descents_composition_list(self.shape):
yield self.from_permutation(p)
class Ribbon_class(RibbonShapedTableau):
"""
This exists solely for unpickling ``Ribbon_class`` objects.
"""
def __setstate__(self, state):
r"""
Unpickle old ``Ribbon_class`` objects.
EXAMPLES::
sage: loads('x\x9ck`J.NLO\xd5K\xce\xcfM\xca\xccK,\xd1+\xcaLJ\xca\xcf\xe3\n\x02S\xf1\xc99\x89\xc5\xc5\\\x85\x8c\x9a\x8d\x85L\xb5\x85\xcc\x1a\xa1\xac\xf1\x19\x89\xc5\x19\x85,~@VNfqI!kl!\x9bFl!\xbb\x06\xc4\x9c\xa2\xcc\xbc\xf4b\xbd\xcc\xbc\x92\xd4\xf4\xd4"\xae\xdc\xc4\xec\xd4x\x18\xa7\x90#\x94\xd1\xb05\xa8\x903\x03\xc80\x022\xb8Rc\x0b\xb95@<c \x8f\x07\xc40\x012xSSK\x93\xf4\x00l\x811\x17')
[[None, 1, 2], [3, 4]]
sage: loads(dumps( RibbonShapedTableau([[3,2,1], [1,1]]) )) # indirect doctest
[[None, 3, 2, 1], [1, 1]]
"""
self.__class__ = RibbonShapedTableau
self.__init__(RibbonShapedTableaux(), state['_list'])
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.combinat.ribbon', 'Ribbon_class', Ribbon_class)
register_unpickle_override('sage.combinat.ribbon', 'StandardRibbons_shape', StandardRibbonShapedTableaux)
# Deprecations from trac:18555. July 2016
from sage.misc.superseded import deprecated_function_alias
RibbonShapedTableaux.global_options = deprecated_function_alias(18555, RibbonShapedTableaux.options)
StandardRibbonShapedTableaux.global_options = deprecated_function_alias(18555, StandardRibbonShapedTableaux.options)
"""
Return the last standard ribbon of ``self``.
EXAMPLES::
sage: StandardRibbonShapedTableaux([2,2]).last()
[[None, 1, 2], [3, 4]]
"""
return self.from_permutation(descents_composition_last(self.shape))
def __iter__(self):
"""
An iterator for the standard ribbon of ``self``.
EXAMPLES::
sage: [t for t in StandardRibbonShapedTableaux([2,2])]
[[[None, 2, 4], [1, 3]],
[[None, 2, 3], [1, 4]],
[[None, 1, 4], [2, 3]],
[[None, 1, 3], [2, 4]],
[[None, 1, 2], [3, 4]]]
"""
for p in descents_composition_list(self.shape):
yield self.from_permutation(p)
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.combinat.ribbon', 'Ribbon_class',
RibbonShapedTableau)
def expand(self, n, alphabet='x'):
"""
Expands the symmetric function as a symmetric polynomial in n
variables.
EXAMPLES::
sage: h = SFAHomogeneous(QQ)
sage: h([3]).expand(2)
x0^3 + x0^2*x1 + x0*x1^2 + x1^3
sage: h([1,1,1]).expand(2)
x0^3 + 3*x0^2*x1 + 3*x0*x1^2 + x1^3
sage: h([2,1]).expand(3)
x0^3 + 2*x0^2*x1 + 2*x0*x1^2 + x1^3 + 2*x0^2*x2 + 3*x0*x1*x2 + 2*x1^2*x2 + 2*x0*x2^2 + 2*x1*x2^2 + x2^3
sage: h([3]).expand(2,alphabet='y')
y0^3 + y0^2*y1 + y0*y1^2 + y1^3
sage: h([3]).expand(2,alphabet='x,y')
x^3 + x^2*y + x*y^2 + y^3
sage: h([3]).expand(3,alphabet='x,y,z')
x^3 + x^2*y + x*y^2 + y^3 + x^2*z + x*y*z + y^2*z + x*z^2 + y*z^2 + z^3
"""
condition = lambda part: False
return self._expand(condition, n, alphabet)
# Backward compatibility for unpickling
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.combinat.sf.homogeneous',
'SymmetricFunctionAlgebraElement_homogeneous',
SymmetricFunctionAlgebra_homogeneous.Element)
INPUT:
- ``self`` -- an element of the symmetric functions in a dual basis
- ``n`` -- a positive integer
- ``alphabet`` -- a variable for the expansion (default: `x`)
OUTPUT:
- a monomial expansion of an instance of dual of ``self`` in `n` variable
EXAMPLES::
sage: m = SymmetricFunctions(QQ).monomial()
sage: zee = sage.combinat.sf.sfa.zee
sage: h = m.dual_basis(zee)
sage: a = h([2,1])+h([3])
sage: a.expand(2)
2*x0^3 + 3*x0^2*x1 + 3*x0*x1^2 + 2*x1^3
sage: a.dual().expand(2)
2*x0^3 + 3*x0^2*x1 + 3*x0*x1^2 + 2*x1^3
sage: a.expand(2,alphabet='y')
2*y0^3 + 3*y0^2*y1 + 3*y0*y1^2 + 2*y1^3
sage: a.expand(2,alphabet='x,y')
2*x^3 + 3*x^2*y + 3*x*y^2 + 2*y^3
"""
return self._dual.expand(n, alphabet)
# Backward compatibility for unpickling
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.combinat.sf.dual', 'SymmetricFunctionAlgebraElement_dual', SymmetricFunctionAlgebra_dual.Element)
a^8 + a^7 + a^4 + a + 1
a^8 + a^7 + a^4 + a + 1
AUTHORS:
- David Joyner and William Stein (2005-11)
"""
from sage.groups.generic import discrete_log
b = self.parent()(base)
# TODO: This function is TERRIBLE!
return discrete_log(self, b)
dynamic_FiniteField_ext_pariElement = None
def _late_import():
"""
Used to reset the class of PARI finite field elements in their initialization.
EXAMPLES::
sage: from sage.rings.finite_rings.element_ext_pari import FiniteField_ext_pariElement
sage: k.<a> = GF(3^17, impl='pari_mod')
sage: a.__class__ is FiniteField_ext_pariElement # indirect doctest
False
"""
global dynamic_FiniteField_ext_pariElement
dynamic_FiniteField_ext_pariElement = dynamic_class("%s_with_category"%FiniteField_ext_pariElement.__name__, (FiniteField_ext_pariElement, FiniteFields().element_class), doccls=FiniteField_ext_pariElement)
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.rings.finite_field_element', 'FiniteField_ext_pariElement', FiniteField_ext_pariElement)
pos = 0 #Double check this
restmp = [ S.from_shape_and_word(parts[0], [l[k][j] for j in range(s[0])]) ]
for i in range(1, len(parts)):
w = [l[k][j] for j in range(pos+s[i-1], pos+s[i-1]+s[i])]
restmp.append( S.from_shape_and_word(parts[i], w) )
yield self.element_class(self, restmp)
class RibbonTableau_class(RibbonTableau):
"""
This exists solely for unpickling ``RibbonTableau_class`` objects.
"""
def __setstate__(self, state):
r"""
Unpickle old ``RibbonTableau_class`` objects.
TESTS::
sage: loads('x\x9c5\xcc\xbd\x0e\xc2 \x14@\xe1\xb4Z\x7f\xd0\x07\xc1\x85D}\x8f\x0e\x8d\x1d\t\xb9\x90\x1bJ\xa44\x17\xe8h\xa2\x83\xef-\xda\xb8\x9do9\xcf\xda$\xb0(\xcc4j\x17 \x8b\xe8\xb4\x9e\x82\xca\xa0=\xc2\xcc\xba\x1fo\x8b\x94\xf1\x90\x12\xa3\xea\xf4\xa2\xfaA+\xde7j\x804\xd0\xba-\xe5]\xca\xd4H\xdapI[\xde.\xdf\xe8\x82M\xc2\x85\x8c\x16#\x1b\xe1\x8e\xea\x0f\xda\xf5\xd5\xf9\xdd\xd1\x1e%1>\x14]\x8a\x0e\xdf\xb8\x968"\xceZ|\x00x\xef5\x11')
[[None, 1], [2, 3]]
sage: loads(dumps( RibbonTableau([[None, 1],[2,3]]) ))
[[None, 1], [2, 3]]
"""
self.__class__ = RibbonTableau
self.__init__(RibbonTableaux(), state['_list'])
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.combinat.ribbon_tableau', 'RibbonTableau_class', RibbonTableau_class)
register_unpickle_override('sage.combinat.ribbon_tableau', 'RibbonTableaux_shapeweightlength', RibbonTableaux)
register_unpickle_override('sage.combinat.ribbon_tableau', 'SemistandardMultiSkewTtableaux_shapeweight', SemistandardMultiSkewTableaux)
TESTS::
sage: Hom(GF(3^3, 'a'), GF(3^6, 'b')).an_element()
Ring morphism:
From: Finite Field in a of size 3^3
To: Finite Field in b of size 3^6
Defn: a |--> 2*b^5 + 2*b^4
sage: Hom(GF(3^3, 'a'), GF(3^2, 'c')).an_element()
Traceback (most recent call last):
...
EmptySetError: no homomorphisms from Finite Field in a of size 3^3 to Finite Field in c of size 3^2
.. TODO::
Use a more sophisticated algorithm; see also :trac:`8751`.
"""
K = self.domain()
L = self.codomain()
if K.degree() == 1:
return L.coerce_map_from(K)
elif not K.degree().divides(L.degree()):
from sage.categories.sets_cat import EmptySetError
raise EmptySetError('no homomorphisms from %s to %s' % (K, L))
return K.hom([K.modulus().any_root(L)])
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.rings.finite_field_morphism', 'FiniteFieldHomset', FiniteFieldHomset)
"""
EXAMPLES::
sage: sage.combinat.skew_tableau.SemistandardSkewTableaux_pmu([[2,1],[]],[2,1])
doctest:1: DeprecationWarning: this class is deprecated. Use SemistandardSkewTableaux_shape_weight instead
See http://trac.sagemath.org/9265 for details.
Semistandard skew tableaux of shape [[2, 1], []] and weight [2, 1]
"""
deprecation(9265,'this class is deprecated. Use SemistandardSkewTableaux_shape_weight instead')
return SemistandardSkewTableaux_shape_weight(*args, **kargs)
def StandardSkewTableaux_n(*args, **kargs):
"""
EXAMPLES::
sage: sage.combinat.skew_tableau.StandardSkewTableaux_n(2)
doctest:1: DeprecationWarning: this class is deprecated. Use StandardSkewTableaux_size instead
See http://trac.sagemath.org/9265 for details.
Standard skew tableaux of size 2
"""
deprecation(9265,'this class is deprecated. Use StandardSkewTableaux_size instead')
return StandardSkewTableaux(*args, **kargs)
# October 2012: fixing outdated pickles which use the classes being deprecated
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.combinat.skew_tableau', 'StandardSkewTableaux_n', StandardSkewTableaux_size)
register_unpickle_override('sage.combinat.skew_tableau', 'SemistandardSkewTableaux_n', SemistandardSkewTableaux_size)
register_unpickle_override('sage.combinat.skew_tableau', 'SemistandardSkewTableaux_nmu', SemistandardSkewTableaux_size_weight)
register_unpickle_override('sage.combinat.skew_tableau', 'SemistandardSkewTableaux_p', SemistandardSkewTableaux_shape)
register_unpickle_override('sage.combinat.skew_tableau', 'SemistandardSkewTableaux_pmu', SemistandardSkewTableaux_shape_weight)
ret = "\\draw (0 cm,0) -- (%s cm,0);\n" % ((n - 2) * node_dist)
ret += "\\draw (%s cm, 0.1 cm) -- +(%s cm,0);\n" % ((n - 2) * node_dist, node_dist)
ret += "\\draw (%s cm, -0.1 cm) -- +(%s cm,0);\n" % ((n - 2) * node_dist, node_dist)
if dual:
ret += self._latex_draw_arrow_tip((n - 1.5) * node_dist - 0.2, 0, 180)
else:
ret += self._latex_draw_arrow_tip((n - 1.5) * node_dist + 0.2, 0, 0)
for i in range(self.n):
ret += node(i * node_dist, 0, label(i + 1))
return ret
def _default_folded_cartan_type(self):
"""
Return the default folded Cartan type.
EXAMPLES::
sage: CartanType(['B', 3])._default_folded_cartan_type()
['B', 3] as a folding of ['D', 4]
"""
from sage.combinat.root_system.type_folded import CartanTypeFolded
n = self.n
return CartanTypeFolded(self, ["D", n + 1], [[i] for i in range(1, n)] + [[n, n + 1]])
# For unpickling backward compatibility (Sage <= 4.1)
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override("sage.combinat.root_system.type_B", "ambient_space", AmbientSpace)
"""
For old pickles of ``MonotoneTriangles_n``.
EXAMPLES::
sage: sage.combinat.alternating_sign_matrix.MonotoneTriangles_n(3)
doctest:...: DeprecationWarning: this class is deprecated. Use sage.combinat.alternating_sign_matrix.MonotoneTriangles instead
See http://trac.sagemath.org/14301 for details.
Monotone triangles with 3 rows
"""
from sage.misc.superseded import deprecation
deprecation(14301,'this class is deprecated. Use sage.combinat.alternating_sign_matrix.MonotoneTriangles instead')
return MonotoneTriangles(n)
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.combinat.alternating_sign_matrix', 'AlternatingSignMatrices_n', AlternatingSignMatrices)
register_unpickle_override('sage.combinat.alternating_sign_matrix', 'MonotoneTriangles_n', MonotoneTriangles)
register_unpickle_override('sage.combinat.alternating_sign_matrix', 'MonotoneTriangles_n', MonotoneTriangles_n)
# Here are the previous implementations of the combinatorial structure
# of the alternating sign matrices. Please, consider it obsolete and
# tend to use the monotone triangles instead.
def from_contre_tableau(comps):
r"""
Returns an alternating sign matrix from a contre-tableau.
EXAMPLES::
sage: import sage.combinat.alternating_sign_matrix as asm
sage: asm.from_contre_tableau([[1, 2, 3], [1, 2], [1]])
INPUT:
- ``self`` -- an instance of the LLT hcospin basis
- ``part`` -- a partition
OUTPUT:
- returns a function which accepts a partition and returns the coefficient
in the expansion of the monomial basis
EXAMPLES::
sage: HCosp3 = SymmetricFunctions(FractionField(QQ['t'])).llt(3).hcospin()
sage: f21 = HCosp3._to_m(Partition([2,1]))
sage: [f21(p) for p in Partitions(3)]
[1, t + 1, 2*t + 1]
sage: HCosp3.symmetric_function_ring().m()( HCosp3[2,1] )
(2*t+1)*m[1, 1, 1] + (t+1)*m[2, 1] + m[3]
"""
level = self.level()
f = lambda part2: QQt(ribbon_tableau.cospin_polynomial([level*i for i in part], part2, level))
return f
class Element(LLT_generic.Element):
pass
# Backward compatibility for unpickling
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.combinat.sf.llt', 'LLTElement_spin', LLT_spin.Element)
register_unpickle_override('sage.combinat.sf.llt', 'LLTElement_cospin', LLT_cospin.Element)
EXAMPLE::
sage: R = Integers(12345678900)
sage: R.degree()
1
"""
return integer.Integer(1)
Zmod = IntegerModRing
Integers = IntegerModRing
# Register unpickling methods for backward compatibility.
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.rings.integer_mod_ring', 'IntegerModRing_generic', IntegerModRing_generic)
## def GF(p):
## """
## EXAMPLES:
## sage: F = GF(11)
## sage: F
## Finite field of size 11
## """
## if not arith.is_prime(p):
## raise NotImplementedError, "Only prime fields currently implemented."
## return IntegerModRing(p)
def crt(v):
"""
INPUT: v - (list) a lift of elements of rings.IntegerMod(n), for
data = QQ(data).continued_fraction_list()
else:
from .continued_fraction import check_and_reduce_pair
data,_ = check_and_reduce_pair(data, [])
return self.element_class(data)
def _coerce_map_from_(self, R):
r"""
Return True for ZZ and QQ.
EXAMPLES::
sage: CFF.has_coerce_map_from(ZZ) # indirect doctest
True
sage: CFF.has_coerce_map_from(QQ)
True
sage: CFF.has_coerce_map_from(RR)
False
"""
from sage.rings.integer_ring import ZZ
from sage.rings.rational_field import QQ
return R is ZZ or R is QQ
CFF = ContinuedFractionField()
# Unpickling support is needed as the class ContinuedFractionField_class has
# been renamed into ContinuedFractionField in the ticket 14567
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.rings.contfrac', 'ContinuedFractionField_class',ContinuedFractionField)
##########################################################
# Deprecations
class SplitNK(OrderedSetPartitions_scomp):
def __setstate__(self, state):
r"""
For unpickling old ``SplitNK`` objects.
TESTS::
sage: loads("x\x9ck`J.NLO\xd5K\xce\xcfM\xca\xccK,\xd1+.\xc8\xc9,"
....: "\x89\xcf\xcb\xe6\n\x061\xfc\xbcA\xccBF\xcd\xc6B\xa6\xda"
....: "Bf\x8dP\xa6\xf8\xbcB\x16\x88\x96\xa2\xcc\xbc\xf4b\xbd\xcc"
....: "\xbc\x92\xd4\xf4\xd4\"\xae\xdc\xc4\xec\xd4x\x18\xa7\x905"
....: "\x94\xd1\xb45\xa8\x90\r\xa8>\xbb\x90=\x03\xc85\x02r9J\x93"
....: "\xf4\x00\xb4\xc6%f")
Ordered set partitions of {0, 1, 2, 3, 4} into parts of size [2, 3]
"""
self.__class__ = OrderedSetPartitions_scomp
n = state['_n']
k = state['_k']
OrderedSetPartitions_scomp.__init__(self, range(state['_n']),
(k, n - k))
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override("sage.combinat.split_nk", "SplitNK_nk", SplitNK)
yield self.element_class(self, restmp)
class RibbonTableau_class(RibbonTableau):
"""
This exists solely for unpickling ``RibbonTableau_class`` objects.
"""
def __setstate__(self, state):
r"""
Unpickle old ``RibbonTableau_class`` objects.
TESTS::
sage: loads('x\x9c5\xcc\xbd\x0e\xc2 \x14@\xe1\xb4Z\x7f\xd0\x07\xc1\x85D}\x8f\x0e\x8d\x1d\t\xb9\x90\x1bJ\xa44\x17\xe8h\xa2\x83\xef-\xda\xb8\x9do9\xcf\xda$\xb0(\xcc4j\x17 \x8b\xe8\xb4\x9e\x82\xca\xa0=\xc2\xcc\xba\x1fo\x8b\x94\xf1\x90\x12\xa3\xea\xf4\xa2\xfaA+\xde7j\x804\xd0\xba-\xe5]\xca\xd4H\xdapI[\xde.\xdf\xe8\x82M\xc2\x85\x8c\x16#\x1b\xe1\x8e\xea\x0f\xda\xf5\xd5\xf9\xdd\xd1\x1e%1>\x14]\x8a\x0e\xdf\xb8\x968"\xceZ|\x00x\xef5\x11')
[[None, 1], [2, 3]]
sage: loads(dumps( RibbonTableau([[None, 1],[2,3]]) ))
[[None, 1], [2, 3]]
"""
self.__class__ = RibbonTableau
self.__init__(RibbonTableaux(), state['_list'])
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.combinat.ribbon_tableau',
'RibbonTableau_class', RibbonTableau_class)
register_unpickle_override('sage.combinat.ribbon_tableau',
'RibbonTableaux_shapeweightlength', RibbonTableaux)
register_unpickle_override('sage.combinat.ribbon_tableau',
'SemistandardMultiSkewTtableaux_shapeweight',
SemistandardMultiSkewTableaux)
- ``self`` -- an element of the homogeneous basis of symmetric functions
- ``n`` -- a positive integer
- ``alphabet`` -- a variable for the expansion (default: `x`)
OUTPUT: a monomial expansion of an instance of ``self`` in `n` variables
EXAMPLES::
sage: h = SymmetricFunctions(QQ).h()
sage: h([3]).expand(2)
x0^3 + x0^2*x1 + x0*x1^2 + x1^3
sage: h([1,1,1]).expand(2)
x0^3 + 3*x0^2*x1 + 3*x0*x1^2 + x1^3
sage: h([2,1]).expand(3)
x0^3 + 2*x0^2*x1 + 2*x0*x1^2 + x1^3 + 2*x0^2*x2 + 3*x0*x1*x2 + 2*x1^2*x2 + 2*x0*x2^2 + 2*x1*x2^2 + x2^3
sage: h([3]).expand(2,alphabet='y')
y0^3 + y0^2*y1 + y0*y1^2 + y1^3
sage: h([3]).expand(2,alphabet='x,y')
x^3 + x^2*y + x*y^2 + y^3
sage: h([3]).expand(3,alphabet='x,y,z')
x^3 + x^2*y + x*y^2 + y^3 + x^2*z + x*y*z + y^2*z + x*z^2 + y*z^2 + z^3
sage: (h([]) + 2*h([1])).expand(3)
2*x0 + 2*x1 + 2*x2 + 1
"""
condition = lambda part: False
return self._expand(condition, n, alphabet)
# Backward compatibility for unpickling
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.combinat.sf.homogeneous', 'SymmetricFunctionAlgebraElement_homogeneous', SymmetricFunctionAlgebra_homogeneous.Element)
sage: range(c.cardinality()) == map(c.rank, c.list())
True
"""
x = map(self.mset.index, x)
return rank(x, len(self.mset))
##########################################################
# Deprecations
class ChooseNK(Combinations_setk):
def __setstate__(self, state):
r"""
For unpickling old ``ChooseNK`` objects.
TESTS::
sage: loads("x\x9ck`J.NLO\xd5K\xce\xcfM\xca\xccK,\xd1K\xce\xc8\xcf"
....: "/N\x8d\xcf\xcb\xe6r\x06\xb3\xfc\xbc\xb9\n\x195\x1b\x0b"
....: "\x99j\x0b\x995B\x99\xe2\xf3\nY :\x8a2\xf3\xd2\x8b\xf52"
....: "\xf3JR\xd3S\x8b\xb8r\x13\xb3S\xe3a\x9cB\xd6PF\xd3\xd6\xa0"
....: "B6\xa0\xfa\xecB\xf6\x0c \xd7\x08\xc8\xe5(M\xd2\x03\x00{"
....: "\x82$\xd8")
Combinations of [0, 1, 2, 3, 4] of length 2
"""
self.__class__ = Combinations_setk
Combinations_setk.__init__(self, range(state['_n']), state['_k'])
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override("sage.combinat.choose_nk", "ChooseNK", ChooseNK)
data = QQ(data).continued_fraction_list()
else:
from continued_fraction import check_and_reduce_pair
data,_ = check_and_reduce_pair(data, [])
return self.element_class(data)
def _coerce_map_from_(self, R):
r"""
Return True for ZZ and QQ.
EXAMPLES::
sage: CFF.has_coerce_map_from(ZZ) # indirect doctest
True
sage: CFF.has_coerce_map_from(QQ)
True
sage: CFF.has_coerce_map_from(RR)
False
"""
from sage.rings.integer_ring import ZZ
from sage.rings.rational_field import QQ
return R is ZZ or R is QQ
CFF = ContinuedFractionField()
# Unpickling support is needed as the class ContinuedFractionField_class has
# been renamed into ContinuedFractionField in the ticket 14567
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.rings.contfrac', 'ContinuedFractionField_class',ContinuedFractionField)
from __future__ import absolute_import
from .base import IntegerListsBackend, Envelope
from .lists import IntegerLists
from .invlex import IntegerListsLex
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.combinat.integer_list', 'IntegerListsLex',
IntegerListsLex)
sage: R = Integers(12345678900)
sage: R.degree()
1
"""
return integer.Integer(1)
Zmod = IntegerModRing
Integers = IntegerModRing
# Register unpickling methods for backward compatibility.
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override("sage.rings.integer_mod_ring", "IntegerModRing_generic", IntegerModRing_generic)
def crt(v):
"""
INPUT:
- ``v`` -- (list) a lift of elements of ``rings.IntegerMod(n)``, for
various coprime moduli ``n``
EXAMPLES::
sage: from sage.rings.finite_rings.integer_mod_ring import crt
sage: crt([mod(3, 8),mod(1,19),mod(7, 15)])
1027
"""
TESTS::
sage: P2.<x,y,z> = AffineSpace(3, GF(3))
sage: point_homset = P2._point_homset(Spec(GF(3)), P2)
sage: P2._point(point_homset, [1, 2, 3])
(1, 2, 0)
"""
return SchemeMorphism_point_affine_finite_field(*args, **kwds)
def _morphism(self, *args, **kwds):
"""
Construct a morphism.
For internal use only. See :mod:`morphism` for details.
TESTS::
sage: P2.<x,y,z> = AffineSpace(3, GF(3))
sage: P2._morphism(P2.Hom(P2), [x, y, z])
Scheme endomorphism of Affine Space of dimension 3 over Finite Field of size 3
Defn: Defined on coordinates by sending (x, y, z) to
(x, y, z)
"""
return SchemeMorphism_polynomial_affine_space_finite_field(*args, **kwds)
#fix the pickles from moving affine_space.py
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.schemes.generic.affine_space',
'AffineSpace_generic',
AffineSpace_generic)
sage: a = P.base_ring().gen()
sage: F = Sequence([x*y + 1, a*x + 1], P)
sage: F2 = F.weil_restriction()
sage: F2
[x1*y0 + x0*y1 + x1*y1,
x0*y0 + x1*y1 + 1,
x0 + x1,
x1 + 1,
x0^2 + x0,
x1^2 + x1,
y0^2 + y0,
y1^2 + y1]
Another bigger example for a small scale AES::
sage: sr = mq.SR(1,1,1,4,gf2=False)
sage: F,s = sr.polynomial_system(); F
Polynomial Sequence with 40 Polynomials in 20 Variables
sage: F2 = F.weil_restriction(); F2
Polynomial Sequence with 240 Polynomials in 80 Variables
"""
from sage.rings.ideal import FieldIdeal
J = self.ideal().weil_restriction()
J += FieldIdeal(J.ring())
return PolynomialSequence(J)
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override("sage.crypto.mq.mpolynomialsystem","MPolynomialSystem_generic", PolynomialSequence_generic)
register_unpickle_override("sage.crypto.mq.mpolynomialsystem","MPolynomialRoundSystem_generic", PolynomialSequence_generic)
yield self.element_class(self, [Set(res[dcomp[i]+1:dcomp[i+1]+1])
for i in range(l)])
##########################################################
# Deprecations
class SplitNK(OrderedSetPartitions_scomp):
def __setstate__(self, state):
r"""
For unpickling old ``SplitNK`` objects.
TESTS::
sage: loads("x\x9ck`J.NLO\xd5K\xce\xcfM\xca\xccK,\xd1+.\xc8\xc9,"
....: "\x89\xcf\xcb\xe6\n\x061\xfc\xbcA\xccBF\xcd\xc6B\xa6\xda"
....: "Bf\x8dP\xa6\xf8\xbcB\x16\x88\x96\xa2\xcc\xbc\xf4b\xbd\xcc"
....: "\xbc\x92\xd4\xf4\xd4\"\xae\xdc\xc4\xec\xd4x\x18\xa7\x905"
....: "\x94\xd1\xb45\xa8\x90\r\xa8>\xbb\x90=\x03\xc85\x02r9J\x93"
....: "\xf4\x00\xb4\xc6%f")
Ordered set partitions of {0, 1, 2, 3, 4} into parts of size [2, 3]
"""
self.__class__ = OrderedSetPartitions_scomp
n = state['_n']
k = state['_k']
OrderedSetPartitions_scomp.__init__(self, range(state['_n']), (k,n-k))
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override("sage.combinat.split_nk", "SplitNK_nk", SplitNK)
# TODO: This function is TERRIBLE!
return discrete_log(self, b)
dynamic_FiniteField_ext_pariElement = None
def _late_import():
"""
Used to reset the class of PARI finite field elements in their initialization.
EXAMPLES::
sage: from sage.rings.finite_rings.element_ext_pari import FiniteField_ext_pariElement
sage: k.<a> = GF(3^17)
sage: a.__class__ is FiniteField_ext_pariElement # indirect doctest
False
"""
global dynamic_FiniteField_ext_pariElement
dynamic_FiniteField_ext_pariElement = dynamic_class(
"%s_with_category" % FiniteField_ext_pariElement.__name__,
(FiniteField_ext_pariElement, FiniteFields().element_class),
doccls=FiniteField_ext_pariElement)
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.rings.finite_field_element',
'FiniteField_ext_pariElement',
FiniteField_ext_pariElement)
sage: del S._Sequence_generic__hash
sage: hash(S)
Traceback (most recent call last):
...
AttributeError: 'Sequence_generic' object has no attribute '_Sequence_generic__hash'
sage: S._Sequence__hash = 34
sage: hash(S)
34
"""
if name == "_Sequence_generic__cr" and hasattr(self,"_Sequence__cr"):
self.__cr = self._Sequence__cr
return self.__cr
elif name == "_Sequence_generic__cr_str" and hasattr(self,"_Sequence__cr_str"):
self.__cr_str = self._Sequence__cr_str
return self.__cr_str
elif name == "_Sequence_generic__immutable" and hasattr(self,"_Sequence__immutable"):
self.__immutable = self._Sequence__immutable
return self.__immutable
elif name == "_Sequence_generic__universe" and hasattr(self,"_Sequence__universe"):
self.__universe = self._Sequence__universe
return self.__universe
elif name == "_Sequence_generic__hash" and hasattr(self,"_Sequence__hash"):
self.__hash = self._Sequence__hash
return self.__hash
else:
raise AttributeError("'Sequence_generic' object has no attribute '%s'"%name)
seq = Sequence
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.structure.sequence', 'Sequence', Sequence_generic)
sage: G = groups.misc.AdditiveCyclic(3)
sage: ZG = G.algebra(ZZ, category=AdditiveMagmas())
sage: ZG.has_coerce_map_from(G)
False
"""
G = self.basis().keys()
K = self.base_ring()
if G.has_coerce_map_from(S):
from sage.categories.groups import Groups
# No coercion for additive groups because of ambiguity of +
# being the group action or addition of a new term.
return self.category().is_subcategory(Groups().Algebras(K))
if S in Sets.Algebras:
S_K = S.base_ring()
S_G = S.basis().keys()
hom_K = K.coerce_map_from(S_K)
hom_G = G.coerce_map_from(S_G)
if hom_K is not None and hom_G is not None:
return SetMorphism(
S.Hom(self, category=self.category() | S.category()),
lambda x: self.sum_of_terms(
(hom_G(g), hom_K(c)) for g, c in x))
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.algebras.group_algebras', 'GroupAlgebra',
GroupAlgebra_class)
Integer Ring
sage: Hom.base_extend(QQ)
Traceback (most recent call last):
...
NotImplementedError: Abelian variety point sets are not
implemented as modules over rings other than ZZ.
"""
if R is not ZZ:
raise NotImplementedError('Abelian variety point sets are not '
'implemented as modules over rings other than ZZ.')
return self
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.schemes.generic.homset',
'SchemeHomsetModule_abelian_variety_coordinates_field',
SchemeHomset_points_abelian_variety_field)
#*******************************************************************
# Toric varieties
#*******************************************************************
class SchemeHomset_points_toric_field(SchemeHomset_points):
"""
Set of rational points of a toric variety.
INPUT:
- same as for :class:`SchemeHomset_points`.
OUPUT:
sage: from sage.modular.modsym.g1list import _G1list_old_pickle
sage: L = _G1list_old_pickle()
sage: type(L) == G1list
True
"""
self.__class__ = G1list
def __setstate__(self, state):
"""
For unpickling new pickles.
TESTS::
sage: from sage.modular.modsym.g1list import G1list
sage: L = G1list(6)
sage: Lp = loads(dumps(L))
sage: L == Lp
True
sage: type(Lp) == G1list
True
"""
# We don't really want this class, but we want to handle new
# pickles without creating a new class
self.__class__ = G1list
self.__dict__ = state # Default pickling is ``state = self.__dict__``
register_unpickle_override('sage.modular.modsym.g1list', 'G1list',
_G1list_old_pickle)
variables.
EXAMPLES::
sage: h = SFAHomogeneous(QQ)
sage: h([3]).expand(2)
x0^3 + x0^2*x1 + x0*x1^2 + x1^3
sage: h([1,1,1]).expand(2)
x0^3 + 3*x0^2*x1 + 3*x0*x1^2 + x1^3
sage: h([2,1]).expand(3)
x0^3 + 2*x0^2*x1 + 2*x0*x1^2 + x1^3 + 2*x0^2*x2 + 3*x0*x1*x2 + 2*x1^2*x2 + 2*x0*x2^2 + 2*x1*x2^2 + x2^3
sage: h([3]).expand(2,alphabet='y')
y0^3 + y0^2*y1 + y0*y1^2 + y1^3
sage: h([3]).expand(2,alphabet='x,y')
x^3 + x^2*y + x*y^2 + y^3
sage: h([3]).expand(3,alphabet='x,y,z')
x^3 + x^2*y + x*y^2 + y^3 + x^2*z + x*y*z + y^2*z + x*z^2 + y*z^2 + z^3
"""
condition = lambda part: False
return self._expand(condition, n, alphabet)
# Backward compatibility for unpickling
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override(
"sage.combinat.sf.homogeneous",
"SymmetricFunctionAlgebraElement_homogeneous",
SymmetricFunctionAlgebra_homogeneous.Element,
)
if weights is not None:
try:
for weight in weights:
new_adj[node1][node2][weight] = {}
except TypeError:
new_adj[node1][node2]['weight'] = weights
if self.multiedges:
G = networkx.MultiDiGraph(new_adj)
else:
G = networkx.DiGraph(new_adj)
return G
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('networkx.xgraph','XGraph', NetworkXGraphDeprecated)
register_unpickle_override('networkx.xdigraph','XDiGraph', NetworkXDiGraphDeprecated)
class NetworkXGraphBackend(GenericGraphBackend):
"""
A wrapper for NetworkX as the backend of a graph.
TESTS::
sage: import sage.graphs.base.graph_backends
"""
_nxg = None
def __init__(self, N=None):
EXAMPLE::
sage: R = Integers(12345678900)
sage: R.degree()
1
"""
return integer.Integer(1)
Zmod = IntegerModRing
Integers = IntegerModRing
# Register unpickling methods for backward compatibility.
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.rings.integer_mod_ring',
'IntegerModRing_generic', IntegerModRing_generic)
def crt(v):
"""
INPUT:
- ``v`` -- (list) a lift of elements of ``rings.IntegerMod(n)``, for
various coprime moduli ``n``
EXAMPLES::
sage: from sage.rings.finite_rings.integer_mod_ring import crt
sage: crt([mod(3, 8),mod(1,19),mod(7, 15)])
1027
"""
for weight in weights:
new_adj[node1][node2][weight] = {}
except TypeError:
new_adj[node1][node2]['weight'] = weights
if self.multiedges:
G = networkx.MultiDiGraph(new_adj)
else:
G = networkx.DiGraph(new_adj)
return G
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('networkx.xgraph', 'XGraph',
NetworkXGraphDeprecated)
register_unpickle_override('networkx.xdigraph', 'XDiGraph',
NetworkXDiGraphDeprecated)
class NetworkXGraphBackend(GenericGraphBackend):
"""
A wrapper for NetworkX as the backend of a graph.
TESTS::
sage: import sage.graphs.base.graph_backends
"""
_nxg = None
sage: QQ.an_element()
1/2
"""
return FormalSum([(self.base_ring().an_element(), 1)],
check=check,
reduce=reduce,
parent=self)
formal_sums = FormalSums()
# Formal sums now derives from UniqueRepresentation, which makes the
# factory function unnecessary. This is why the name was changed from
# class FormalSums_generic to class FormalSums.
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.structure.formal_sum', 'FormalSums_generic',
FormalSums)
class FormalSum(ModuleElement):
"""
A formal sum over a ring.
"""
def __init__(self, x, parent=formal_sums, check=True, reduce=True):
"""
INPUT:
- ``x`` -- object
- ``parent`` -- FormalSums(R) module (default: FormalSums(ZZ))
- ``check`` -- bool (default: True) if False, might not coerce
coefficients into base ring, which can speed
up constructing a formal sum.
- ``reduce`` -- reduce (default: True) if False, do not
i = n
while i > 0:
P = [0 for _ in range(n + 1)]
for ai in R:
P[i] = ai
for tup in S[i - 1]:
if gcd([ai] + tup) == 1:
for j in range(i):
P[j] = tup[j]
pts.append(self(P))
i -= 1
# now do i=0; this is treated as a special case so that
# we don't have all points (1:0),(2,0),(3,0),etc.
P = [0 for _ in range(n + 1)]
P[0] = 1
pts.append(self(P))
return pts
#fix the pickles from moving projective_space.py
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.schemes.generic.projective_space',
'ProjectiveSpace_field', ProjectiveSpace_field)
register_unpickle_override('sage.schemes.generic.projective_space',
'ProjectiveSpace_rational_field',
ProjectiveSpace_rational_field)
pass
class Polynomial_generic_cdvf(Polynomial_generic_cdv,
Polynomial_generic_field):
pass
class Polynomial_generic_dense_cdvf(Polynomial_generic_dense_cdv,
Polynomial_generic_cdvf):
pass
class Polynomial_generic_sparse_cdvf(Polynomial_generic_sparse_cdv,
Polynomial_generic_cdvf):
pass
############################################################################
# XXX: Ensures that the generic polynomials implemented in SAGE via PARI #
# until at least until 4.5.0 unpickle correctly as polynomials implemented #
# via FLINT. #
from sage.structure.sage_object import (register_unpickle_override, richcmp,
richcmp_not_equal, rich_to_bool,
rich_to_bool_sgn)
from sage.rings.polynomial.polynomial_rational_flint import Polynomial_rational_flint
register_unpickle_override( \
'sage.rings.polynomial.polynomial_element_generic', \
'Polynomial_rational_dense', Polynomial_rational_flint)
sage: P2.<x,y,z> = AffineSpace(3, GF(3))
sage: point_homset = P2._point_homset(Spec(GF(3)), P2)
sage: P2._point(point_homset, [1,2,3])
(1, 2, 0)
"""
return SchemeMorphism_point_affine_finite_field(*args, **kwds)
def _morphism(self, *args, **kwds):
"""
Construct a morphism.
For internal use only. See :mod:`morphism` for details.
TESTS::
sage: P2.<x,y,z> = AffineSpace(3, GF(3))
sage: P2._morphism(P2.Hom(P2), [x,y,z])
Scheme endomorphism of Affine Space of dimension 3 over Finite Field of size 3
Defn: Defined on coordinates by sending (x, y, z) to
(x, y, z)
"""
return SchemeMorphism_polynomial_affine_space_finite_field(
*args, **kwds)
#fix the pickles from moving affine_space.py
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.schemes.generic.affine_space',
'AffineSpace_generic', AffineSpace_generic)
sage: a = P.base_ring().gen()
sage: F = Sequence([x*y + 1, a*x + 1], P)
sage: F2 = F.weil_restriction()
sage: F2
[x1*y0 + x0*y1 + x1*y1,
x0*y0 + x1*y1 + 1,
x0 + x1,
x1 + 1,
x0^2 + x0,
x1^2 + x1,
y0^2 + y0,
y1^2 + y1]
Another bigger example for a small scale AES::
sage: sr = mq.SR(1,1,1,4,gf2=False)
sage: F,s = sr.polynomial_system(); F
Polynomial Sequence with 40 Polynomials in 20 Variables
sage: F2 = F.weil_restriction(); F2
Polynomial Sequence with 240 Polynomials in 80 Variables
"""
from sage.rings.ideal import FieldIdeal
J = self.ideal().weil_restriction()
J += FieldIdeal(J.ring())
return PolynomialSequence(J)
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override("sage.crypto.mq.mpolynomialsystem","MPolynomialSystem_generic", PolynomialSequence_generic)
register_unpickle_override("sage.crypto.mq.mpolynomialsystem","MPolynomialRoundSystem_generic", PolynomialSequence_generic)
sage: Hom(GF(3^3, 'a'), GF(3^6, 'b')).an_element()
Ring morphism:
From: Finite Field in a of size 3^3
To: Finite Field in b of size 3^6
Defn: a |--> 2*b^5 + 2*b^4
sage: Hom(GF(3^3, 'a'), GF(3^2, 'c')).an_element()
Traceback (most recent call last):
...
EmptySetError: no homomorphisms from Finite Field in a of size 3^3 to Finite Field in c of size 3^2
.. TODO::
Use a more sophisticated algorithm; see also :trac:`8751`.
"""
K = self.domain()
L = self.codomain()
if K.degree() == 1:
return L.coerce_map_from(K)
elif not K.degree().divides(L.degree()):
from sage.categories.sets_cat import EmptySetError
raise EmptySetError('no homomorphisms from %s to %s' % (K, L))
return K.hom([K.modulus().any_root(L)])
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.rings.finite_field_morphism',
'FiniteFieldHomset', FiniteFieldHomset)
Finite family {1: (1, 0, 0, 0), 2: (1, 1, 0, 0), 3: (1/2, 1/2, 1/2, -1/2), 4: (1/2, 1/2, 1/2, 1/2)}
"""
if i not in self.index_set():
raise ValueError("{} is not in the index set".format(i))
n = self.dimension()
if i == n:
return self.sum(self.monomial(j) for j in range(n)) / 2
elif i == n - 1:
return (self.sum(self.monomial(j)
for j in range(n - 1)) - self.monomial(n - 1)) / 2
else:
return self.sum(self.monomial(j) for j in range(i))
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.combinat.root_system.type_A', 'ambient_space',
AmbientSpace)
from sage.misc.cachefunc import cached_method
from cartan_type import CartanType_standard_finite, CartanType_simply_laced, CartanType_simple
class CartanType(CartanType_standard_finite, CartanType_simply_laced):
def __init__(self, n):
"""
EXAMPLES::
sage: ct = CartanType(['D',4])
sage: ct
['D', 4]
sage: ct._repr_(compact = True)
'D4'
class Polynomial_generic_sparse_field(Polynomial_generic_sparse, Polynomial_generic_field):
"""
EXAMPLES::
sage: R.<x> = PolynomialRing(Frac(RR['t']), sparse=True)
sage: f = x^3 - x + 17
sage: type(f)
<class 'sage.rings.polynomial.polynomial_element_generic.PolynomialRing_field_with_category.element_class'>
sage: loads(f.dumps()) == f
True
"""
def __init__(self, parent, x=None, check=True, is_gen = False, construct=False):
Polynomial_generic_sparse.__init__(self, parent, x, check, is_gen)
class Polynomial_generic_dense_field(Polynomial_generic_dense, Polynomial_generic_field):
def __init__(self, parent, x=None, check=True, is_gen = False, construct=False):
Polynomial_generic_dense.__init__(self, parent, x, check, is_gen)
############################################################################
# XXX: Ensures that the generic polynomials implemented in SAGE via PARI #
# until at least until 4.5.0 unpickle correctly as polynomials implemented #
# via FLINT. #
from sage.structure.sage_object import register_unpickle_override
from sage.rings.polynomial.polynomial_rational_flint import Polynomial_rational_flint
register_unpickle_override( \
'sage.rings.polynomial.polynomial_element_generic', \
'Polynomial_rational_dense', Polynomial_rational_flint)
"""
for p in descents_composition_list(self.shape):
yield self.from_permutation(p)
class Ribbon_class(RibbonShapedTableau):
"""
This exists solely for unpickling ``Ribbon_class`` objects.
"""
def __setstate__(self, state):
r"""
Unpickle old ``Ribbon_class`` objects.
EXAMPLES::
sage: loads('x\x9ck`J.NLO\xd5K\xce\xcfM\xca\xccK,\xd1+\xcaLJ\xca\xcf\xe3\n\x02S\xf1\xc99\x89\xc5\xc5\\\x85\x8c\x9a\x8d\x85L\xb5\x85\xcc\x1a\xa1\xac\xf1\x19\x89\xc5\x19\x85,~@VNfqI!kl!\x9bFl!\xbb\x06\xc4\x9c\xa2\xcc\xbc\xf4b\xbd\xcc\xbc\x92\xd4\xf4\xd4"\xae\xdc\xc4\xec\xd4x\x18\xa7\x90#\x94\xd1\xb05\xa8\x903\x03\xc80\x022\xb8Rc\x0b\xb95@<c \x8f\x07\xc40\x012xSSK\x93\xf4\x00l\x811\x17')
[[None, 1, 2], [3, 4]]
sage: loads(dumps( RibbonShapedTableau([[3,2,1], [1,1]]) )) # indirect doctest
[[None, 3, 2, 1], [1, 1]]
"""
self.__class__ = RibbonShapedTableau
self.__init__(RibbonShapedTableaux(), state['_list'])
from sage.structure.sage_object import register_unpickle_override
register_unpickle_override('sage.combinat.ribbon', 'Ribbon_class', Ribbon_class)
register_unpickle_override('sage.combinat.ribbon', 'StandardRibbons_shape', StandardRibbonShapedTableaux)
# Deprecations from trac:18555. July 2016
from sage.misc.superseded import deprecated_function_alias
RibbonShapedTableaux.global_options = deprecated_function_alias(18555, RibbonShapedTableaux.options)
StandardRibbonShapedTableaux.global_options = deprecated_function_alias(18555, StandardRibbonShapedTableaux.options)
sage: eps = DirichletGroup(4).gen(0)
sage: from sage.modular.modsym.manin_symbol_list import ManinSymbolList_character
sage: m = ManinSymbolList_character(eps,4); m
Manin Symbol List of weight 4 for Gamma1(4) with character [-1]
sage: [m.normalize(s.tuple()) for s in m.manin_symbol_list()]
[((0, 0, 1), 1),
((0, 1, 0), 1),
((0, 1, 1), 1),
...
((2, 1, 3), 1),
((2, 2, 1), 1)]
"""
u, v, s = self.__P1.normalize_with_scalar(x[1], x[2])
return (x[0], u, v), self.__character(s)
register_unpickle_override('sage.modular.modsym.manin_symbols',
'ManinSymbolList', ManinSymbolList)
register_unpickle_override('sage.modular.modsym.manin_symbols',
'ManinSymbolList_group', ManinSymbolList_group)
register_unpickle_override('sage.modular.modsym.manin_symbols',
'ManinSymbolList_gamma0', ManinSymbolList_gamma0)
register_unpickle_override('sage.modular.modsym.manin_symbols',
'ManinSymbolList_gamma1', ManinSymbolList_gamma1)
register_unpickle_override('sage.modular.modsym.manin_symbols',
'ManinSymbolList_gamma_h', ManinSymbolList_gamma_h)
register_unpickle_override('sage.modular.modsym.manin_symbols',
'ManinSymbolList_character',
ManinSymbolList_character)