def __richcmp__(self, other, op):
"""
Return 0 if self == other, and 1 or -1 otherwise.
We consider two p-adic rings or fields to be equal if they are
equal mathematically, and also have the same precision cap and
printing parameters.
EXAMPLES::
sage: R = Qp(7)
sage: S = Qp(7,print_mode='val-unit')
sage: R == S
False
sage: S = Qp(7,type='capped-rel')
sage: R == S
True
sage: R is S
True
"""
if not isinstance(other, pAdicGeneric):
return NotImplemented
lx = self.prime()
rx = other.prime()
if lx != rx:
return richcmp_not_equal(lx, rx, op)
lx = self.precision_cap()
rx = other.precision_cap()
if lx != rx:
return richcmp_not_equal(lx, rx, op)
return self._printer.richcmp_modes(other._printer, op)
def __richcmp__(self, other, op):
"""
Return 0 if self == other, and 1 or -1 otherwise.
We consider two p-adic rings or fields to be equal if they are
equal mathematically, and also have the same precision cap and
printing parameters.
EXAMPLES::
sage: R = Qp(7)
sage: S = Qp(7,print_mode='val-unit')
sage: R == S
False
sage: S = Qp(7,type='capped-rel')
sage: R == S
True
sage: R is S
True
"""
if not isinstance(other, pAdicGeneric):
return NotImplemented
lx = self.prime()
rx = other.prime()
if lx != rx:
return richcmp_not_equal(lx, rx, op)
lx = self.precision_cap()
rx = other.precision_cap()
if lx != rx:
return richcmp_not_equal(lx, rx, op)
return self._printer.richcmp_modes(other._printer, op)
def __richcmp__(self, other, op):
"""
Compare ``self`` and ``other``.
This first compares the values.
If values are equal, this compares the units.
If units are equal, this compares the underlying lists of
``self`` and ``other``.
EXAMPLES:
We compare two contrived formal factorizations::
sage: a = Factorization([(2, 7), (5,2), (2, 5)])
sage: b = Factorization([(2, 7), (5,10), (7, 3)])
sage: a
2^12 * 5^2
sage: b
2^7 * 5^10 * 7^3
sage: a < b
True
sage: b < a
False
sage: a.value()
102400
sage: b.value()
428750000000
We compare factorizations of some polynomials::
sage: x = polygen(QQ)
sage: x^2 - 1 > x^2 - 4
True
sage: factor(x^2 - 1) > factor(x^2 - 4)
True
"""
if not isinstance(other, Factorization):
return NotImplemented
lx = self.value()
rx = other.value()
if lx != rx:
return richcmp_not_equal(lx, rx, op)
lx = self.__unit
rx = other.__unit
if lx != rx:
return richcmp_not_equal(lx, rx, op)
return richcmp(self.__x, other.__x, op)
def __richcmp__(self, other, op):
"""
Compare ``self`` and ``other``.
This first compares the values.
If values are equal, this compares the units.
If units are equal, this compares the underlying lists of
``self`` and ``other``.
EXAMPLES:
We compare two contrived formal factorizations::
sage: a = Factorization([(2, 7), (5,2), (2, 5)])
sage: b = Factorization([(2, 7), (5,10), (7, 3)])
sage: a
2^12 * 5^2
sage: b
2^7 * 5^10 * 7^3
sage: a < b
True
sage: b < a
False
sage: a.value()
102400
sage: b.value()
428750000000
We compare factorizations of some polynomials::
sage: x = polygen(QQ)
sage: x^2 - 1 > x^2 - 4
True
sage: factor(x^2 - 1) > factor(x^2 - 4)
True
"""
if not isinstance(other, Factorization):
return NotImplemented
lx = self.value()
rx = other.value()
if lx != rx:
return richcmp_not_equal(lx, rx, op)
lx = self.__unit
rx = other.__unit
if lx != rx:
return richcmp_not_equal(lx, rx, op)
return richcmp(self.__x, other.__x, op)
def _richcmp_(self, other, op):
"""
Compare two free monoid elements with the same parents.
The ordering is first by increasing length, then lexicographically
on the underlying word.
EXAMPLES::
sage: S = FreeMonoid(3, 'a')
sage: (x,y,z) = S.gens()
sage: x * y < y * x
True
sage: a = FreeMonoid(5, 'a').gens()
sage: x = a[0]*a[1]*a[4]**3
sage: x < x
False
sage: x == x
True
sage: x >= x*x
False
"""
m = sum(i for x, i in self._element_list)
n = sum(i for x, i in other._element_list)
if m != n:
return richcmp_not_equal(m, n, op)
v = tuple([x for x, i in self._element_list for j in range(i)])
w = tuple([x for x, i in other._element_list for j in range(i)])
return richcmp(v, w, op)
def _richcmp_(self, other, op):
"""
Compare two free monoid elements with the same parents.
The ordering is first by increasing length, then lexicographically
on the underlying word.
EXAMPLES::
sage: S = FreeMonoid(3, 'a')
sage: (x,y,z) = S.gens()
sage: x * y < y * x
True
sage: a = FreeMonoid(5, 'a').gens()
sage: x = a[0]*a[1]*a[4]**3
sage: x < x
False
sage: x == x
True
sage: x >= x*x
False
"""
m = sum(i for x, i in self._element_list)
n = sum(i for x, i in other._element_list)
if m != n:
return richcmp_not_equal(m, n, op)
v = tuple([x for x, i in self._element_list for j in range(i)])
w = tuple([x for x, i in other._element_list for j in range(i)])
return richcmp(v, w, op)
def __richcmp__(self, other, op):
"""
Compare self to other.
EXAMPLES::
sage: M = ModularSymbols(12,6)
sage: S = sage.modular.hecke.submodule.HeckeSubmodule(M, M.cuspidal_submodule().free_module())
sage: T = sage.modular.hecke.submodule.HeckeSubmodule(M, M.new_submodule().free_module())
sage: S
Rank 14 submodule of a Hecke module of level 12
sage: T
Rank 0 submodule of a Hecke module of level 12
sage: S > T
True
sage: T < S
True
sage: S == S
True
"""
if not isinstance(other, module.HeckeModule_free_module):
return NotImplemented
lx = self.ambient()
rx = other.ambient()
if lx != rx:
return richcmp_not_equal(lx, rx, op)
return self.free_module()._echelon_matrix_richcmp(other.free_module(), op)
def __richcmp__(self, other, op):
"""
Compare self to other.
EXAMPLES::
sage: M = ModularSymbols(12,6)
sage: S = sage.modular.hecke.submodule.HeckeSubmodule(M, M.cuspidal_submodule().free_module())
sage: T = sage.modular.hecke.submodule.HeckeSubmodule(M, M.new_submodule().free_module())
sage: S
Rank 14 submodule of a Hecke module of level 12
sage: T
Rank 0 submodule of a Hecke module of level 12
sage: S > T
True
sage: T < S
True
sage: S == S
True
"""
if not isinstance(other, module.HeckeModule_free_module):
return NotImplemented
lx = self.ambient()
rx = other.ambient()
if lx != rx:
return richcmp_not_equal(lx, rx, op)
return self.free_module()._echelon_matrix_richcmp(other.free_module(), op)
def _richcmp_(self, other, op):
r"""
Standard comparison function for the WeierstrassIsomorphism class.
EXAMPLES::
sage: from sage.schemes.elliptic_curves.weierstrass_morphism import *
sage: E = EllipticCurve('389a1')
sage: F = E.change_weierstrass_model(1,2,3,4)
sage: w1 = E.isomorphism_to(F)
sage: w1 == w1
True
sage: w2 = F.automorphisms()[0] *w1
sage: w1 == w2
False
sage: E = EllipticCurve_from_j(GF(7)(0))
sage: F = E.change_weierstrass_model(2,3,4,5)
sage: a = E.isomorphisms(F)
sage: b = [w*a[0] for w in F.automorphisms()]
sage: b.sort()
sage: a == b
True
sage: c = [a[0]*w for w in E.automorphisms()]
sage: c.sort()
sage: a == c
True
"""
if isinstance(other, WeierstrassIsomorphism):
lx = self._domain
rx = other._domain
if lx != rx:
return richcmp_not_equal(lx, rx, op)
lx = self._codomain
rx = other._codomain
if lx != rx:
return richcmp_not_equal(lx, rx, op)
return baseWI.__richcmp__(self, other, op)
return EllipticCurveHom._richcmp_(self, other, op)
def _richcmp_(self, other, op):
"""
Compare this polynomial with other.
Polynomials are first compared by degree, then in dictionary order
starting with the coefficient of largest degree.
EXAMPLES::
sage: R.<x> = PolynomialRing(ZZ, sparse=True)
sage: 3*x^100 - 12 > 12*x + 5
True
sage: 3*x^100 - 12 > 3*x^100 - x^50 + 5
True
sage: 3*x^100 - 12 < 3*x^100 - x^50 + 5
False
sage: x^100 + x^10 - 1 < x^100 + x^10
True
sage: x^100 < x^100 - x^10
False
TESTS::
sage: R.<x> = PolynomialRing(QQ, sparse=True)
sage: 2*x^2^500 > x^2^500
True
sage: Rd = PolynomialRing(ZZ, 'x', sparse=False)
sage: Rs = PolynomialRing(ZZ, 'x', sparse=True)
sage: for _ in range(100):
....: pd = Rd.random_element()
....: qd = Rd.random_element()
....: assert cmp(pd,qd) == cmp(Rs(pd), Rs(qd))
"""
d1 = self.degree()
d2 = other.degree()
# Special case constant polynomials
if d1 <= 0 and d2 <= 0:
return richcmp(self[0], other[0], op)
# For different degrees, compare the degree
if d1 != d2:
return rich_to_bool_sgn(op, d1 - d2)
degs = set(self.__coeffs) | set(other.__coeffs)
for i in sorted(degs, reverse=True):
x = self[i]
y = other[i]
if x != y:
return richcmp_not_equal(x, y, op)
return rich_to_bool(op, 0)
def _richcmp_(self, other, op):
"""
Compare this polynomial with other.
Polynomials are first compared by degree, then in dictionary order
starting with the coefficient of largest degree.
EXAMPLES::
sage: R.<x> = PolynomialRing(ZZ, sparse=True)
sage: 3*x^100 - 12 > 12*x + 5
True
sage: 3*x^100 - 12 > 3*x^100 - x^50 + 5
True
sage: 3*x^100 - 12 < 3*x^100 - x^50 + 5
False
sage: x^100 + x^10 - 1 < x^100 + x^10
True
sage: x^100 < x^100 - x^10
False
TESTS::
sage: R.<x> = PolynomialRing(QQ, sparse=True)
sage: 2*x^2^500 > x^2^500
True
sage: Rd = PolynomialRing(ZZ, 'x', sparse=False)
sage: Rs = PolynomialRing(ZZ, 'x', sparse=True)
sage: for _ in range(100):
....: pd = Rd.random_element()
....: qd = Rd.random_element()
....: assert cmp(pd,qd) == cmp(Rs(pd), Rs(qd))
"""
d1 = self.degree()
d2 = other.degree()
# Special case constant polynomials
if d1 <= 0 and d2 <= 0:
return richcmp(self[0], other[0], op)
# For different degrees, compare the degree
if d1 != d2:
return rich_to_bool_sgn(op, d1 - d2)
degs = set(self.__coeffs) | set(other.__coeffs)
for i in sorted(degs, reverse=True):
x = self[i]
y = other[i]
if x != y:
return richcmp_not_equal(x, y, op)
return rich_to_bool(op, 0)
def _richcmp_(self, other, op):
r"""
Standard comparison function for the WeierstrassIsomorphism class.
EXAMPLES::
sage: from sage.schemes.elliptic_curves.weierstrass_morphism import *
sage: E = EllipticCurve('389a1')
sage: F = E.change_weierstrass_model(1,2,3,4)
sage: w1 = E.isomorphism_to(F)
sage: w1 == w1
True
sage: w2 = F.automorphisms()[0] *w1
sage: w1 == w2
False
sage: E = EllipticCurve_from_j(GF(7)(0))
sage: F = E.change_weierstrass_model(2,3,4,5)
sage: a = E.isomorphisms(F)
sage: b = [w*a[0] for w in F.automorphisms()]
sage: b.sort()
sage: a == b
True
sage: c = [a[0]*w for w in E.automorphisms()]
sage: c.sort()
sage: a == c
True
"""
lx = self._domain_curve
rx = other._domain_curve
if lx != rx:
return richcmp_not_equal(lx, rx, op)
lx = self._codomain_curve
rx = other._codomain_curve
if lx != rx:
return richcmp_not_equal(lx, rx, op)
return baseWI.__richcmp__(self, other, op)
def _richcmp_(self, other, op):
"""
EXAMPLES::
sage: W = WeylGroup(['A',3])
sage: s = W.simple_reflections()
sage: s[1] == s[1]
True
sage: s[1] == s[2]
False
"""
if self._parent.cartan_type() != other._parent.cartan_type():
return richcmp_not_equal(self._parent.cartan_type(),
other._parent.cartan_type(), op)
return richcmp(self.matrix(), other.matrix(), op)
def _richcmp_(self, other, op):
"""
EXAMPLES::
sage: W = WeylGroup(['A',3])
sage: s = W.simple_reflections()
sage: s[1] == s[1]
True
sage: s[1] == s[2]
False
"""
if self._parent.cartan_type() != other._parent.cartan_type():
return richcmp_not_equal(self._parent.cartan_type(),
other._parent.cartan_type(), op)
return richcmp(self.matrix(), other.matrix(), op)
def __richcmp__(self, other, op):
r"""
Compare ``self`` to ``other``.
EXAMPLES::
sage: J0(37).homology().decomposition() # indirect doctest
[
Submodule of rank 2 of Integral Homology of Abelian variety J0(37) of dimension 2,
Submodule of rank 2 of Integral Homology of Abelian variety J0(37) of dimension 2
]
"""
if not isinstance(other, Homology_submodule):
return NotImplemented
lx = self.__ambient
rx = other.__ambient
if lx != rx:
return richcmp_not_equal(lx, rx, op)
return richcmp(self.__submodule, other.__submodule, op)
def __richcmp__(self, other, op):
"""
Compare ``self`` and ``other``.
.. warning::
This method tests whether the underlying representation is
the same. Use :meth:`is_isomorphic` to test for
mathematical equivalence.
INPUT:
- ``other`` -- anything.
OUTPUT:
Boolean.
EXAMPLES::
sage: X = toric_varieties.P2()
sage: V1 = X.sheaves.trivial_bundle(1)
sage: V2 = X.sheaves.trivial_bundle(2)
sage: V2 == V1
False
sage: V2 == V1+V1
True
sage: T_X = X.sheaves.tangent_bundle()
sage: O_X = X.sheaves.trivial_bundle(1)
sage: T_X + O_X == O_X + T_X
False
"""
if not isinstance(other, KlyachkoBundle_class):
return NotImplemented
lx = self.variety()
rx = other.variety()
if lx != rx:
return richcmp_not_equal(lx, rx, op)
return richcmp(self._filt, other._filt, op)
def __richcmp__(self, other, op):
"""
Compare ``self`` and ``other``.
.. warning::
This method tests whether the underlying representation is
the same. Use :meth:`is_isomorphic` to test for
mathematical equivalence.
INPUT:
- ``other`` -- anything.
OUTPUT:
Boolean.
EXAMPLES::
sage: X = toric_varieties.P2()
sage: V1 = X.sheaves.trivial_bundle(1)
sage: V2 = X.sheaves.trivial_bundle(2)
sage: V2 == V1
False
sage: V2 == V1+V1
True
sage: T_X = X.sheaves.tangent_bundle()
sage: O_X = X.sheaves.trivial_bundle(1)
sage: T_X + O_X == O_X + T_X
False
"""
if not isinstance(other, KlyachkoBundle_class):
return NotImplemented
lx = self.variety()
rx = other.variety()
if lx != rx:
return richcmp_not_equal(lr, rx, op)
return richcmp(self._filt, other._filt, op)
def _richcmp_(self, other, op):
"""
Compare ``self`` with ``other``.
OUTPUT:
boolean
EXAMPLES::
sage: F = AffineGroup(3, QQ)
sage: g = F([1,2,3,4,5,6,7,8,0], [10,11,12])
sage: h = F([1,2,3,4,5,6,7,8,0], [10,11,0])
sage: g == h
False
sage: g == g
True
"""
lx = self._A
rx = other._A
if lx != rx:
return richcmp_not_equal(lx, rx, op)
return richcmp(self._b, other._b, op)
def _richcmp_(self, other, op):
"""
Compare ``self`` with ``other``.
OUTPUT:
boolean
EXAMPLES::
sage: F = AffineGroup(3, QQ)
sage: g = F([1,2,3,4,5,6,7,8,0], [10,11,12])
sage: h = F([1,2,3,4,5,6,7,8,0], [10,11,0])
sage: g == h
False
sage: g == g
True
"""
lx = self._A
rx = other._A
if lx != rx:
return richcmp_not_equal(lx, rx, op)
return richcmp(self._b, other._b, op)
def _richcmp_(self, other, op):
r"""
Compare :class:`EllipticCurveHom` objects.
ALGORITHM:
This method compares domains, codomains, and :meth:`rational_maps`.
EXAMPLES::
sage: E = EllipticCurve(QQ, [0,0,0,1,0])
sage: phi_v = EllipticCurveIsogeny(E, E((0,0)))
sage: phi_k = EllipticCurveIsogeny(E, [0,1])
sage: phi_k == phi_v
True
sage: E_F17 = EllipticCurve(GF(17), [0,0,0,1,0])
sage: phi_p = EllipticCurveIsogeny(E_F17, [0,1])
sage: phi_p == phi_v
False
sage: E = EllipticCurve('11a1')
sage: phi = E.isogeny(E(5,5))
sage: phi == phi
True
sage: phi == -phi
False
sage: psi = E.isogeny(phi.kernel_polynomial())
sage: phi == psi
True
sage: phi.dual() == psi.dual()
True
::
sage: from sage.schemes.elliptic_curves.weierstrass_morphism import WeierstrassIsomorphism
sage: E = EllipticCurve([9,9])
sage: F = E.change_ring(GF(71))
sage: wE = WeierstrassIsomorphism(E, (1,0,0,0))
sage: wF = WeierstrassIsomorphism(F, (1,0,0,0))
sage: mE = E.multiplication_by_m_isogeny(1)
sage: mF = F.multiplication_by_m_isogeny(1)
sage: [mE == wE, mF == wF]
[True, True]
sage: [a == b for a in (wE,mE) for b in (wF,mF)]
[False, False, False, False]
"""
# We cannot just compare kernel polynomials, as was done until
# Trac #11327, as then phi and -phi compare equal, and
# similarly with phi and any composition of phi with an
# automorphism of its codomain, or any post-isomorphism.
# Comparing domains, codomains and rational maps seems much
# safer.
lx, rx = self.domain(), other.domain()
if lx != rx:
return richcmp_not_equal(lx, rx, op)
lx, rx = self.codomain(), other.codomain()
if lx != rx:
return richcmp_not_equal(lx, rx, op)
lx, rx = self.degree(), other.degree()
if lx != rx:
return richcmp_not_equal(lx, rx, op)
return richcmp(self.rational_maps(), other.rational_maps(), op)
def __richcmp__(self, other, op):
"""
Implement rich comparison.
We treat two matrix groups as equal if their generators are
the same in the same order. Infinitely-generated groups are
compared by identity.
INPUT:
- ``other`` -- anything
- ``op`` -- comparison operator
OUTPUT:
boolean
EXAMPLES::
sage: G = GL(2,3)
sage: H = MatrixGroup(G.gens())
sage: H == G
True
sage: G == H
True
sage: MS = MatrixSpace(QQ, 2, 2)
sage: G = MatrixGroup([MS(1), MS([1,2,3,4])])
sage: G == G
True
sage: G == MatrixGroup(G.gens())
True
TESTS::
sage: G = groups.matrix.GL(4,2)
sage: H = MatrixGroup(G.gens())
sage: G == H
True
sage: G != H
False
"""
if not is_MatrixGroup(other):
return NotImplemented
if self is other:
return rich_to_bool(op, 0)
lx = self.matrix_space()
rx = other.matrix_space()
if lx != rx:
return richcmp_not_equal(lx, rx, op)
# compare number of generators
try:
n_self = self.ngens()
n_other = other.ngens()
except (AttributeError, NotImplementedError):
return richcmp(id(self), id(other), op)
if n_self != n_other:
return richcmp_not_equal(self, other, op)
from sage.structure.element import is_InfinityElement
if is_InfinityElement(n_self) or is_InfinityElement(n_other):
return richcmp(id(self), id(other), op)
# compact generator matrices
try:
self_gens = self.gens()
other_gens = other.gens()
except (AttributeError, NotImplementedError):
return richcmp(id(self), id(other), op)
assert(n_self == n_other)
for g, h in zip(self_gens, other_gens):
lx = g.matrix()
rx = h.matrix()
if lx != rx:
return richcmp_not_equal(lx, rx, op)
return rich_to_bool(op, 0)
def __richcmp__(self, other, op):
"""
Implement rich comparison.
We treat two matrix groups as equal if their generators are
the same in the same order. Infinitely-generated groups are
compared by identity.
INPUT:
- ``other`` -- anything
- ``op`` -- comparison operator
OUTPUT:
boolean
EXAMPLES::
sage: G = GL(2,3)
sage: H = MatrixGroup(G.gens())
sage: H == G
True
sage: G == H
True
sage: MS = MatrixSpace(QQ, 2, 2)
sage: G = MatrixGroup([MS(1), MS([1,2,3,4])])
sage: G == G
True
sage: G == MatrixGroup(G.gens())
True
TESTS::
sage: G = groups.matrix.GL(4,2)
sage: H = MatrixGroup(G.gens())
sage: G == H
True
sage: G != H
False
"""
if not is_MatrixGroup(other):
return NotImplemented
if self is other:
return rich_to_bool(op, 0)
lx = self.matrix_space()
rx = other.matrix_space()
if lx != rx:
return richcmp_not_equal(lx, rx, op)
# compare number of generators
try:
n_self = self.ngens()
n_other = other.ngens()
except (AttributeError, NotImplementedError):
return richcmp(id(self), id(other), op)
if n_self != n_other:
return richcmp_not_equal(self, other, op)
from sage.structure.element import is_InfinityElement
if is_InfinityElement(n_self) or is_InfinityElement(n_other):
return richcmp(id(self), id(other), op)
# compact generator matrices
try:
self_gens = self.gens()
other_gens = other.gens()
except (AttributeError, NotImplementedError):
return richcmp(id(self), id(other), op)
assert (n_self == n_other)
for g, h in zip(self_gens, other_gens):
lx = g.matrix()
rx = h.matrix()
if lx != rx:
return richcmp_not_equal(lx, rx, op)
return rich_to_bool(op, 0)
