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 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): 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): 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): 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): 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)