def _test_additive_associativity(self, **options): r""" Test associativity for (not necessarily all) elements of this additive semigroup. INPUT: - ``options`` -- any keyword arguments accepted by :meth:`_tester` EXAMPLES: By default, this method tests only the elements returned by ``self.some_elements()``:: sage: R = QpFP(7,3) sage: R._test_additive_associativity() However, the elements tested can be customized with the ``elements`` keyword argument:: sage: R._test_additive_associativity(elements = [R(0), ~R(0), R(42)]) See the documentation for :class:`TestSuite` for more information. """ tester = self._tester(**options) S = tester.some_elements() from sage.misc.misc import some_tuples for x, y, z in some_tuples(S, 3, tester._max_runs): tester.assertTrue(((x + y) + z).is_equal_to( x + (y + z), min(x.precision_absolute(), y.precision_absolute(), z.precision_absolute())))
def _test_additive_associativity(self, **options): r""" Test associativity for (not necessarily all) elements of this additive semigroup. INPUT: - ``options`` -- any keyword arguments accepted by :meth:`_tester` EXAMPLES: By default, this method tests only the elements returned by ``self.some_elements()``:: sage: R = QpFP(7,3) sage: R._test_additive_associativity() However, the elements tested can be customized with the ``elements`` keyword argument:: sage: R._test_additive_associativity(elements = [R(0), ~R(0), R(42)]) See the documentation for :class:`TestSuite` for more information. """ tester = self._tester(**options) S = tester.some_elements() from sage.misc.misc import some_tuples for x,y,z in some_tuples(S, 3, tester._max_runs): tester.assertTrue(((x + y) + z).is_equal_to(x + (y + z), min(x.precision_absolute(), y.precision_absolute(), z.precision_absolute())))
def _test_distributivity(self, **options): r""" Test the distributivity of `*` on `+` on (not necessarily all) elements of this set. INPUT: - ``options`` -- any keyword arguments accepted by :meth:`_tester` EXAMPLES: By default, this method runs the tests only on the elements returned by ``self.some_elements()``:: sage: NN.some_elements() [0, 1, 3, 42] sage: NN._test_distributivity() However, the elements tested can be customized with the ``elements`` keyword argument:: sage: CC._test_distributivity(elements=[CC(0),CC(1),CC(3),CC(I)]) See the documentation for :class:`TestSuite` for more information. """ tester = self._tester(**options) S = tester.some_elements() from sage.misc.misc import some_tuples for x, y, z in some_tuples(tester.some_elements(), 3, tester._max_runs): # left distributivity tester.assertTrue(x * (y + z) == (x * y) + (x * z)) # right distributivity tester.assertTrue((x + y) * z == (x * z) + (y * z))
def _test_sub(self, **options): """ Test subtraction on elements of this ring. INPUT: - ``options`` -- any keyword arguments accepted by :meth:`_tester`. EXAMPLES:: sage: Zp(3)._test_sub() .. SEEALSO:: :class:`TestSuite` """ tester = self._tester(**options) elements = list(tester.some_elements()) for x in elements: y = x - self.zero() tester.assertEqual(y, x) tester.assertEqual(y.precision_absolute(), x.precision_absolute()) tester.assertEqual(y.precision_relative(), x.precision_relative()) for x,y in some_tuples(elements, 2, tester._max_runs): z = x - y tester.assertIs(z.parent(), self) tester.assertEqual(z.precision_absolute(), min(x.precision_absolute(), y.precision_absolute())) tester.assertGreaterEqual(z.valuation(), min(x.valuation(),y.valuation())) if x.valuation() != y.valuation(): tester.assertEqual(z.valuation(), min(x.valuation(),y.valuation())) tester.assertEqual(z - x, -y) tester.assertEqual(z + y, x)
def _test_associativity(self, **options): r""" Test associativity for (not necessarily all) elements of this semigroup. INPUT: - ``options`` -- any keyword arguments accepted by :meth:`_tester` EXAMPLES: By default, this method tests only the elements returned by ``self.some_elements()``:: sage: L = Semigroups().example(choice='leftzero') sage: L._test_associativity() However, the elements tested can be customized with the ``elements`` keyword argument:: sage: L._test_associativity(elements = (L(1), L(2), L(3))) See the documentation for :class:`TestSuite` for more information. """ tester = self._tester(**options) S = tester.some_elements() from sage.misc.misc import some_tuples for x,y,z in some_tuples(S, 3, tester._max_runs): tester.assert_((x * y) * z == x * (y * z))
def _test_mul(self, **options): """ Test multiplication of elements of this ring. INPUT: - ``options`` -- any keyword arguments accepted by :meth:`_tester`. EXAMPLES:: sage: Zp(3)._test_mul() .. SEEALSO:: :class:`TestSuite` """ tester = self._tester(**options) elements = list(tester.some_elements()) for x, y in some_tuples(elements, 2, tester._max_runs): z = x * y tester.assertIs(z.parent(), self) tester.assertLessEqual( z.precision_relative(), min(x.precision_relative(), y.precision_relative())) if not z.is_zero(): tester.assertEqual(z.valuation(), x.valuation() + y.valuation())
def _test_distributivity(self, **options): r""" Test the distributivity of `*` on `+` on (not necessarily all) elements of this set. INPUT: - ``options`` -- any keyword arguments accepted by :meth:`_tester` EXAMPLES: By default, this method runs the tests only on the elements returned by ``self.some_elements()``:: sage: NN.some_elements() [0, 1, 3, 42] sage: NN._test_distributivity() However, the elements tested can be customized with the ``elements`` keyword argument:: sage: CC._test_distributivity(elements=[CC(0),CC(1),CC(3),CC(I)]) See the documentation for :class:`TestSuite` for more information. """ tester = self._tester(**options) S = tester.some_elements() from sage.misc.misc import some_tuples for x,y,z in some_tuples(tester.some_elements(), 3, tester._max_runs): # left distributivity tester.assert_(x * (y + z) == (x * y) + (x * z)) # right distributivity tester.assert_((x + y) * z == (x * z) + (y * z))
def _test_euclidean_degree(self, **options): r""" Test that the assumptions on a euclidean degree are met. EXAMPLES:: sage: R.<x> = QQ[] sage: R._test_euclidean_degree() .. SEEALSO:: :meth:`_test_quo_rem` """ tester = self._tester(**options) S = [s for s in tester.some_elements() if not s.is_zero()] min_degree = self.one().euclidean_degree() from sage.rings.all import NN for a in S: tester.assertIn(a.euclidean_degree(), NN) tester.assertGreaterEqual(a.euclidean_degree(), min_degree) tester.assertEqual(a.euclidean_degree() == min_degree, a.is_unit()) from sage.misc.misc import some_tuples for a,b in some_tuples(S, 2, tester._max_runs): p = a * b # For rings which are not exact, we might get something that # acts like a zero divisor. # Therefore we skip the product if it evaluates to zero. # Let the category of Domains handle the test for zero divisors. if p.is_zero(): continue tester.assertLessEqual(a.euclidean_degree(), p.euclidean_degree())
def _test_div(self, **options): """ Test division of elements of this ring. INPUT: - ``options`` -- any keyword arguments accepted by :meth:`_tester`. EXAMPLES:: sage: Zp(3)._test_div() .. SEEALSO:: :class:`TestSuite` """ tester = self._tester(**options) elements = list(tester.some_elements()) for x,y in some_tuples(elements, 2, tester._max_runs): try: z = x / y except (ZeroDivisionError, PrecisionError, ValueError): if self.is_fixed_mod(): tester.assertFalse(y.is_unit()) else: tester.assertTrue(y.is_zero()) else: tester.assertFalse(y.is_zero()) tester.assertIs(z.parent(), self if self.is_fixed_mod() else self.fraction_field()) tester.assertEqual(z.precision_relative(), min(x.precision_relative(), y.precision_relative())) tester.assertEqual(z.valuation(), x.valuation() - y.valuation())
def _test_quo_rem(self, **options): r""" Test that the assumptions on a quotient with remainder of an euclidean domain are met. EXAMPLES:: sage: R.<x> = QQ[] sage: R._test_quo_rem() .. SEEALSO:: :meth:`_test_euclidean_degree` """ tester = self._tester(**options) S = tester.some_elements() from sage.misc.misc import some_tuples for a,b in some_tuples(S, 2, tester._max_runs): if b.is_zero(): tester.assertRaises(ZeroDivisionError, lambda: a.quo_rem(b)) else: q,r = a.quo_rem(b) tester.assertIn(q, self) tester.assertIn(r, self) tester.assertEqual(a,q*b+r) if r != 0: tester.assertLess(r.euclidean_degree(), b.euclidean_degree())
def _test_euclidean_degree(self, **options): r""" Test that the assumptions on an Euclidean degree are met. EXAMPLES:: sage: R.<x> = QQ[] sage: R._test_euclidean_degree() .. SEEALSO:: :meth:`_test_quo_rem` """ tester = self._tester(**options) S = [s for s in tester.some_elements() if not s.is_zero()] min_degree = self.one().euclidean_degree() from sage.rings.all import NN for a in S: tester.assertIn(a.euclidean_degree(), NN) tester.assertGreaterEqual(a.euclidean_degree(), min_degree) tester.assertEqual(a.euclidean_degree() == min_degree, a.is_unit()) from sage.misc.misc import some_tuples for a,b in some_tuples(S, 2, tester._max_runs): p = a * b # For rings which are not exact, we might get something that # acts like a zero divisor. # Therefore we skip the product if it evaluates to zero. # Let the category of Domains handle the test for zero divisors. if p.is_zero(): continue tester.assertLessEqual(a.euclidean_degree(), p.euclidean_degree())
def _test_additive_associativity(self, **options): r""" Test associativity for (not necessarily all) elements of this additive semigroup. INPUT: - ``options`` -- any keyword arguments accepted by :meth:`_tester` EXAMPLES: By default, this method tests only the elements returned by ``self.some_elements()``:: sage: S = CommutativeAdditiveSemigroups().example() sage: S._test_additive_associativity() However, the elements tested can be customized with the ``elements`` keyword argument:: sage: (a,b,c,d) = S.additive_semigroup_generators() sage: S._test_additive_associativity(elements = (a, b+c, d)) See the documentation for :class:`TestSuite` for more information. """ tester = self._tester(**options) S = tester.some_elements() from sage.misc.misc import some_tuples for x, y, z in some_tuples(S, 3, tester._max_runs): tester.assert_((x + y) + z == x + (y + z))
def _test_additive_associativity(self, **options): r""" Test associativity for (not necessarily all) elements of this additive semigroup. INPUT: - ``options`` -- any keyword arguments accepted by :meth:`_tester` EXAMPLES: By default, this method tests only the elements returned by ``self.some_elements()``:: sage: S = CommutativeAdditiveSemigroups().example() sage: S._test_additive_associativity() However, the elements tested can be customized with the ``elements`` keyword argument:: sage: (a,b,c,d) = S.additive_semigroup_generators() sage: S._test_additive_associativity(elements = (a, b+c, d)) See the documentation for :class:`TestSuite` for more information. """ tester = self._tester(**options) S = tester.some_elements() from sage.misc.misc import some_tuples for x,y,z in some_tuples(S, 3, tester._max_runs): tester.assert_((x + y) + z == x + (y + z))
def _test_mul(self, **options): """ Test multiplication of elements of this ring. INPUT: - ``options`` -- any keyword arguments accepted by :meth:`_tester`. EXAMPLES:: sage: Zp(3)._test_mul() .. SEEALSO:: :class:`TestSuite` """ tester = self._tester(**options) elements = list(tester.some_elements()) for x,y in some_tuples(elements, 2, tester._max_runs): z = x * y tester.assertIs(z.parent(), self) tester.assertLessEqual(z.precision_relative(), min(x.precision_relative(), y.precision_relative())) if not z.is_zero(): tester.assertEqual(z.valuation(), x.valuation() + y.valuation())
def _test_quo_rem(self, **options): r""" Test that the assumptions on a quotient with remainder of an euclidean domain are met. EXAMPLES:: sage: R.<x> = QQ[] sage: R._test_quo_rem() .. SEEALSO:: :meth:`_test_euclidean_degree` """ tester = self._tester(**options) S = tester.some_elements() from sage.misc.misc import some_tuples for a, b in some_tuples(S, 2, tester._max_runs): if b.is_zero(): tester.assertRaises(ZeroDivisionError, lambda: a.quo_rem(b)) else: q, r = a.quo_rem(b) tester.assertIn(q, self) tester.assertIn(r, self) tester.assertEqual(a, q * b + r) if r != 0: tester.assertLess(r.euclidean_degree(), b.euclidean_degree())
def _test_associativity(self, **options): r""" Test associativity for (not necessarily all) elements of this semigroup. INPUT: - ``options`` -- any keyword arguments accepted by :meth:`_tester` EXAMPLES: By default, this method tests only the elements returned by ``self.some_elements()``:: sage: L = Semigroups().example(choice='leftzero') sage: L._test_associativity() However, the elements tested can be customized with the ``elements`` keyword argument:: sage: L._test_associativity(elements = (L(1), L(2), L(3))) See the documentation for :class:`TestSuite` for more information. """ tester = self._tester(**options) S = tester.some_elements() from sage.misc.misc import some_tuples for x, y, z in some_tuples(S, 3, tester._max_runs): tester.assert_((x * y) * z == x * (y * z))
def _test_distributivity(self, **options): r""" Test the distributivity of `*` on `+` on (not necessarily all) elements of this set. p-adic floating point rings only satisfy distributivity up to a precision that depends on the elements. INPUT: - ``options`` -- any keyword arguments accepted by :meth:`_tester` EXAMPLES: By default, this method runs the tests only on the elements returned by ``self.some_elements()``:: sage: R = ZpFP(5,3) sage: R.some_elements() [0, 1, 5, 1 + 3*5 + 3*5^2, 5 + 4*5^2 + 4*5^3] sage: R._test_distributivity() However, the elements tested can be customized with the ``elements`` keyword argument:: sage: R._test_distributivity(elements=[R(0),~R(0),R(42)]) See the documentation for :class:`TestSuite` for more information. """ tester = self._tester(**options) S = tester.some_elements() from sage.misc.misc import some_tuples for x, y, z in some_tuples(S, 3, tester._max_runs): yz_prec = min(y.precision_absolute(), z.precision_absolute()) yz_val = (y + z).valuation() try: prec = min( x.valuation() + yz_val + min(x.precision_relative(), yz_prec - yz_val), x.valuation() + y.valuation() + (x * y).precision_relative(), x.valuation() + z.valuation() + (x * z).precision_relative()) except SignError: pass else: if prec > -infinity: # only check left distributivity, since multiplication commutative tester.assertTrue((x * (y + z)).is_equal_to( (x * y) + (x * z), prec))
def _test_distributivity(self, **options): r""" Test the distributivity of the Lie bracket `[,]` on `+` on (not necessarily all) elements of this set. INPUT: - ``options`` -- any keyword arguments accepted by :meth:`_tester`. TESTS:: sage: L = LieAlgebras(QQ).example() sage: L._test_distributivity() EXAMPLES: By default, this method runs the tests only on the elements returned by ``self.some_elements()``:: sage: L = LieAlgebra(QQ, 3, 'x,y,z', representation="polynomial") sage: L.some_elements() [x + y + z] sage: L._test_distributivity() However, the elements tested can be customized with the ``elements`` keyword argument:: sage: L = LieAlgebra(QQ, cartan_type=['A', 2]) # todo: not implemented - #16821 sage: h1 = L.gen(0) # todo: not implemented - #16821 sage: h2 = L.gen(1) # todo: not implemented - #16821 sage: e2 = L.gen(3) # todo: not implemented - #16821 sage: L._test_distributivity(elements=[h1, h2, e2]) # todo: not implemented - #16821 See the documentation for :class:`TestSuite` for more information. """ tester = self._tester(**options) S = tester.some_elements() from sage.misc.misc import some_tuples for x, y, z in some_tuples(S, 3, tester._max_runs): # left distributivity tester.assertTrue( self.bracket(x, (y + z)) == self.bracket(x, y) + self.bracket(x, z)) # right distributivity tester.assertTrue( self.bracket((x + y), z) == self.bracket(x, z) + self.bracket(y, z))
def _test_verlinde(self, **options): """ Check the Verlinde formula for this :class:`FusionRing` instance. EXAMPLES:: sage: G22 = FusionRing("G2",2) sage: G22._test_verlinde() """ tester = self._tester(**options) c = self.global_q_dimension() i0 = self.one() from sage.misc.misc import some_tuples B = self.basis() for x,y,z in some_tuples(B, 3, tester._max_runs): v = sum(self.s_ij(x,w) * self.s_ij(y,w) * self.s_ij(z,w) / self.s_ij(i0,w) for w in B) tester.assertEqual(v, c * self.N_ijk(x,y,z))
def _test_log(self, **options): """ Test the log operator on elements of this ring. INPUT: - ``options`` -- any keyword arguments accepted by :meth:`_tester`. EXAMPLES:: sage: Zp(3)._test_log() .. SEEALSO:: :class:`TestSuite` """ tester = self._tester(**options) for x in tester.some_elements(): if x.is_zero(): continue l = x.log(p_branch=0) tester.assertIs(l.parent(), self) tester.assertGreater(l.valuation(), 0) if self.is_capped_absolute() or self.is_capped_relative(): tester.assertEqual(x.precision_relative(), l.precision_absolute()) if self.is_capped_absolute() or self.is_capped_relative(): # In the fixed modulus setting, rounding errors may occur elements = list(tester.some_elements()) for x, y, b in some_tuples(elements, 3, tester._max_runs): if x.is_zero() or y.is_zero(): continue r1 = x.log(pi_branch=b) + y.log(pi_branch=b) r2 = (x * y).log(pi_branch=b) tester.assertEqual(r1, r2) p = self.prime() for x in tester.some_elements(): if x.is_zero(): continue if p == 2: a = 4 * x.unit_part() else: a = p * x.unit_part() b = a.exp().log() c = (1 + a).log().exp() tester.assertEqual(a, b) tester.assertEqual(1 + a, c)
def _test_distributivity(self, **options): r""" Test the distributivity of the Lie bracket `[,]` on `+` on (not necessarily all) elements of this set. INPUT: - ``options`` -- any keyword arguments accepted by :meth:`_tester`. TESTS:: sage: L = LieAlgebras(QQ).example() sage: L._test_distributivity() EXAMPLES: By default, this method runs the tests only on the elements returned by ``self.some_elements()``:: sage: L = LieAlgebra(QQ, 3, 'x,y,z', representation="polynomial") sage: L.some_elements() [x + y + z] sage: L._test_distributivity() However, the elements tested can be customized with the ``elements`` keyword argument:: sage: L = LieAlgebra(QQ, cartan_type=['A', 2]) # todo: not implemented - #16821 sage: h1 = L.gen(0) # todo: not implemented - #16821 sage: h2 = L.gen(1) # todo: not implemented - #16821 sage: e2 = L.gen(3) # todo: not implemented - #16821 sage: L._test_distributivity(elements=[h1, h2, e2]) # todo: not implemented - #16821 See the documentation for :class:`TestSuite` for more information. """ tester = self._tester(**options) S = tester.some_elements() from sage.misc.misc import some_tuples for x,y,z in some_tuples(S, 3, tester._max_runs): # left distributivity tester.assertTrue(self.bracket(x, (y + z)) == self.bracket(x, y) + self.bracket(x, z)) # right distributivity tester.assertTrue(self.bracket((x + y), z) == self.bracket(x, z) + self.bracket(y, z))
def _test_distributivity(self, **options): r""" Test the distributivity of `*` on `+` on (not necessarily all) elements of this set. p-adic floating point rings only satisfy distributivity up to a precision that depends on the elements. INPUT: - ``options`` -- any keyword arguments accepted by :meth:`_tester` EXAMPLES: By default, this method runs the tests only on the elements returned by ``self.some_elements()``:: sage: R = ZpFP(5,3) sage: R.some_elements() [0, 1, 5, 1 + 3*5 + 3*5^2, 5 + 4*5^2 + 4*5^3] sage: R._test_distributivity() However, the elements tested can be customized with the ``elements`` keyword argument:: sage: R._test_distributivity(elements=[R(0),~R(0),R(42)]) See the documentation for :class:`TestSuite` for more information. """ tester = self._tester(**options) S = tester.some_elements() from sage.misc.misc import some_tuples for x,y,z in some_tuples(S, 3, tester._max_runs): yz_prec = min(y.precision_absolute(), z.precision_absolute()) yz_val = (y + z).valuation() try: prec = min(x.valuation() + yz_val + min(x.precision_relative(), yz_prec - yz_val), x.valuation() + y.valuation() + (x * y).precision_relative(), x.valuation() + z.valuation() + (x * z).precision_relative()) except SignError: pass else: if prec > -infinity: # only check left distributivity, since multiplication commutative tester.assertTrue((x * (y + z)).is_equal_to((x * y) + (x * z),prec))
def _test_log(self, **options): """ Test the log operator on elements of this ring. INPUT: - ``options`` -- any keyword arguments accepted by :meth:`_tester`. EXAMPLES:: sage: Zp(3)._test_log() .. SEEALSO:: :class:`TestSuite` """ tester = self._tester(**options) for x in tester.some_elements(): if x.is_zero(): continue l = x.log(p_branch=0) tester.assertIs(l.parent(), self) tester.assertGreater(l.valuation(), 0) if self.is_capped_absolute() or self.is_capped_relative(): tester.assertEqual(x.precision_relative(), l.precision_absolute()) if self.is_capped_absolute() or self.is_capped_relative(): # In the fixed modulus setting, rounding errors may occur elements = list(tester.some_elements()) for x, y, b in some_tuples(elements, 3, tester._max_runs): if x.is_zero() or y.is_zero(): continue r1 = x.log(pi_branch=b) + y.log(pi_branch=b) r2 = (x*y).log(pi_branch=b) tester.assertEqual(r1, r2) p = self.prime() for x in tester.some_elements(): if x.is_zero(): continue if p == 2: a = 4 * x.unit_part() else: a = p * x.unit_part() b = a.exp().log() c = (1+a).log().exp() tester.assertEqual(a, b) tester.assertEqual(1+a, c)
def some_elements(self): """ Some elements of this Lie conformal algebra. This method returns a list with elements containing at least the generators. EXAMPLES:: sage: V = lie_conformal_algebras.Affine(QQ, 'A1', names=('e', 'h', 'f')) sage: V.some_elements() [e, h, f, K, Th + 4*T^(2)e, 4*T^(2)h, Te + 4*T^(2)e, Te + 4*T^(2)h] """ S = list(self.gens()) from sage.misc.misc import some_tuples for x,y in some_tuples(S, 2, 0, max_samples=self.ngens()): S.append(x.T() + 2*y.T(2)) return S
def _test_grading(self, **options): r""" Tests that the Lie bracket respects the grading. INPUT: - ``options`` -- any keyword arguments accepted by :meth:`_tester`. EXAMPLES:: sage: C = LieAlgebras(QQ).WithBasis().Graded() sage: C = C.FiniteDimensional().Stratified().Nilpotent() sage: L = LieAlgebra(QQ, {('x','y'): {'z': 1}}, ....: nilpotent=True, category=C) sage: L._test_grading() sage: L = LieAlgebra(QQ, {('x','y'): {'x': 1}}, ....: nilpotent=True, category=C) sage: L._test_grading() Traceback (most recent call last): ... AssertionError: Lie bracket [x, y] has degree 1, not degree 2 See the documentation for :class:`TestSuite` for more information. """ tester = self._tester(**options) from sage.misc.misc import some_tuples for X, Y in some_tuples(self.basis(), 2, tester._max_runs): i = X.degree() j = Y.degree() Z = self.bracket(X, Y) if Z == 0: continue Zdeg = Z.degree() tester.assertEqual( Zdeg, i + j, msg="Lie bracket [%s, %s] has degree %s, not degree %s " % (X, Y, Zdeg, i + j)) tester.assertIn(Z.to_vector(), self.homogeneous_component_as_submodule(i + j), msg="Lie bracket [%s, %s] is not in the " "homogeneous component of degree %s" % (X, Y, i + j))
def _test_database(self, **options): r""" Method used by TestSuite. Performs :meth:`KnotInfoBase.is_recoverable`. EXAMPLES:: sage: from sage.databases.knotinfo_db import KnotInfoDataBase sage: ki_db = KnotInfoDataBase() sage: TestSuite(ki_db).run() # long time indirect doctest """ from sage.knots.knotinfo import KnotInfo from sage.misc.misc import some_tuples tester = options['tester'] max_samples = tester._max_samples if not max_samples: max_samples = 20 l = list(KnotInfo) sample = some_tuples(l, 1, len(l), max_samples=max_samples) tester.assertTrue(all(L.is_recoverable(unique=False) for L, in sample))
def some_elements(self): """ Some elements of this Lie conformal algebra. Returns a list with elements containing at least the generators. EXAMPLES:: sage: V = lie_conformal_algebras.Affine(QQ, 'A1', names=('e', 'h', 'f')) sage: V.some_elements() [e, h, f, K, ...] sage: all(v.parent() is V for v in V.some_elements()) True """ S = list(self.gens()) from sage.misc.misc import some_tuples for x, y in some_tuples(S, 2, 0, max_samples=self.ngens()): S.append(x.T() + 2 * y.T(2)) return S
def _test_add(self, **options): """ Test addition of elements of this ring. INPUT: - ``options`` -- any keyword arguments accepted by :meth:`_tester`. EXAMPLES:: sage: Zp(3)._test_add() .. SEEALSO:: :class:`TestSuite` """ tester = self._tester(**options) elements = tester.some_elements() for x in elements: y = x + self.zero() tester.assertEqual(y, x) tester.assertEqual(y.precision_absolute(), x.precision_absolute()) tester.assertEqual(y.precision_relative(), x.precision_relative()) for x, y in some_tuples(elements, 2, tester._max_runs): z = x + y tester.assertIs(z.parent(), self) zprec = min(x.precision_absolute(), y.precision_absolute()) if self.is_lattice_prec(): tester.assertGreaterEqual(z.precision_absolute(), zprec) elif not self.is_floating_point(): tester.assertEqual(z.precision_absolute(), zprec) tester.assertGreaterEqual(z.valuation(), min(x.valuation(), y.valuation())) if x.valuation() != y.valuation(): tester.assertEqual(z.valuation(), min(x.valuation(), y.valuation())) tester.assertTrue(y.is_equal_to(z - x, zprec)) tester.assertTrue(x.is_equal_to(z - y, zprec))
def _test_grading(self, **options): r""" Tests that the Lie bracket respects the grading. INPUT: - ``options`` -- any keyword arguments accepted by :meth:`_tester`. EXAMPLES:: sage: C = LieAlgebras(QQ).WithBasis().Graded() sage: C = C.FiniteDimensional().Stratified().Nilpotent() sage: L = LieAlgebra(QQ, {('x','y'): {'z': 1}}, ....: nilpotent=True, category=C) sage: L._test_grading() sage: L = LieAlgebra(QQ, {('x','y'): {'x': 1}}, ....: nilpotent=True, category=C) sage: L._test_grading() Traceback (most recent call last): ... AssertionError: Lie bracket [x, y] has degree 1, not degree 2 See the documentation for :class:`TestSuite` for more information. """ tester = self._tester(**options) from sage.misc.misc import some_tuples for X, Y in some_tuples(self.basis(), 2, tester._max_runs): i = X.degree() j = Y.degree() Z = self.bracket(X, Y) if Z == 0: continue Zdeg = Z.degree() tester.assertEqual(Zdeg, i + j, msg="Lie bracket [%s, %s] has degree %s, not degree %s " % (X, Y, Zdeg, i + j)) tester.assertTrue( Z.to_vector() in self.homogeneous_component_as_submodule(i + j), msg="Lie bracket [%s, %s] is not in the " "homogeneous component of degree %s" % (X, Y, i + j))
def _test_zero_divisors(self, **options): """ Check to see that there are no zero divisors. .. NOTE:: In rings whose elements can not be represented exactly, there may be zero divisors in practice, even though these rings do not have them in theory. For such inexact rings, these tests are not performed: sage: R = ZpFM(5); R 5-adic Ring of fixed modulus 5^20 sage: R.is_exact() False sage: a = R(5^19) sage: a.is_zero() False sage: (a*a).is_zero() True sage: R._test_zero_divisors() EXAMPLES:: sage: ZZ._test_zero_divisors() sage: ZpFM(5)._test_zero_divisors() """ if not self.is_exact(): return # Can't check on inexact rings tester = self._tester(**options) # Filter out zero S = [s for s in tester.some_elements() if not s.is_zero()] from sage.misc.misc import some_tuples for a,b in some_tuples(S, 2, tester._max_runs): p = a * b tester.assertFalse(p.is_zero())
def _test_add(self, **options): """ Test addition of elements of this ring. INPUT: - ``options`` -- any keyword arguments accepted by :meth:`_tester`. EXAMPLES:: sage: Zp(3)._test_add() .. SEEALSO:: :class:`TestSuite` """ tester = self._tester(**options) elements = tester.some_elements() for x in elements: y = x + self.zero() tester.assertEqual(y,x) tester.assertEqual(y.precision_absolute(),x.precision_absolute()) tester.assertEqual(y.precision_relative(),x.precision_relative()) for x,y in some_tuples(elements, 2, tester._max_runs): z = x + y tester.assertIs(z.parent(), self) zprec = min(x.precision_absolute(), y.precision_absolute()) if self.is_lattice_prec(): tester.assertGreaterEqual(z.precision_absolute(), zprec) elif not self.is_floating_point(): tester.assertEqual(z.precision_absolute(), zprec) tester.assertGreaterEqual(z.valuation(), min(x.valuation(),y.valuation())) if x.valuation() != y.valuation(): tester.assertEqual(z.valuation(), min(x.valuation(),y.valuation())) tester.assertTrue(y.is_equal_to(z-x,zprec)) tester.assertTrue(x.is_equal_to(z-y,zprec))
def _test_supercommutativity(self, **options): r""" Test supercommutativity for (not necessarily all) elements of this supercommutative algebra. INPUT: - ``options`` -- any keyword arguments accepted by :meth:`_tester` EXAMPLES: By default, this method tests only the elements returned by ``self.some_elements()``:: sage: E.<x,y,z> = ExteriorAlgebra(QQ) sage: E._test_supercommutativity() However, the elements tested can be customized with the ``elements`` keyword argument, but the elements must be homogeneous:: sage: E._test_supercommutativity(elements=[x+y, x*y-3*y*z, x*y*z]) sage: E._test_supercommutativity(elements=[x+x*y]) Traceback (most recent call last): ... ValueError: element is not homogeneous See the documentation for :class:`TestSuite` for more information. """ elements = options.pop("elements", self.basis()) tester = self._tester(**options) from sage.misc.misc import some_tuples for x, y in some_tuples(elements, 2, tester._max_runs): tester.assertEqual( (x * y), (-1)**(x.is_even_odd() * y.is_even_odd()) * (y * x))
def some_elements(self, S=None, repeat=None): """ Return a list (or iterable) of elements of the instance on which the tests should be run. This is only meaningful for container objects like parents. INPUT: - ``S`` -- a set of elements to select from. By default this will use the elements passed to this tester at creation time, or the result of :meth:`.some_elements` if no elements were specified. - ``repeat`` -- integer (default: None). If given, instead returns a list of tuples of length ``repeat`` from ``S``. OUTPUT: A list of at most ``self._max_runs`` elements of ``S^r``, or a sample of at most ``self._max_samples`` if that is not ``None``. EXAMPLES: By default, this calls :meth:`.some_elements` on the instance:: sage: from sage.misc.sage_unittest import InstanceTester sage: class MyParent(Parent): ....: def some_elements(self): ....: return [1,2,3,4,5] ... sage: tester = InstanceTester(MyParent()) sage: list(tester.some_elements()) [1, 2, 3, 4, 5] sage: tester = InstanceTester(MyParent(), max_runs=3) sage: list(tester.some_elements()) [1, 2, 3] sage: tester = InstanceTester(MyParent(), max_runs=7) sage: list(tester.some_elements()) [1, 2, 3, 4, 5] sage: tester = InstanceTester(MyParent(), elements=[1,3,5]) sage: list(tester.some_elements()) [1, 3, 5] sage: tester = InstanceTester(MyParent(), elements=[1,3,5], max_runs=2) sage: list(tester.some_elements()) [1, 3] sage: tester = InstanceTester(FiniteEnumeratedSet(['a','b','c','d']), max_runs=3) sage: tester.some_elements() ['a', 'b', 'c'] sage: tester = InstanceTester(FiniteEnumeratedSet([])) sage: list(tester.some_elements()) [] sage: tester = InstanceTester(ZZ) sage: ZZ.some_elements() # yikes, shamelessly trivial ... <generator object ..._some_elements_from_iterator at 0x...> sage: list(tester.some_elements()) [0, 1, -1, 2, -2, ..., 49, -49, 50] sage: tester = InstanceTester(ZZ, elements = ZZ, max_runs=5) sage: list(tester.some_elements()) [0, 1, -1, 2, -2] sage: tester = InstanceTester(ZZ, elements = srange(100), max_runs=5) sage: list(tester.some_elements()) [0, 1, 2, 3, 4] sage: tester = InstanceTester(ZZ, elements = srange(3), max_runs=5) sage: list(tester.some_elements()) [0, 1, 2] The ``repeat`` keyword can give pairs or triples from ``S``:: sage: list(tester.some_elements(repeat=2)) [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1)] You can use ``max_samples`` to sample at random, instead of in order:: sage: tester = InstanceTester(ZZ, elements = srange(8), max_samples = 4) sage: list(tester.some_elements()) [0, 3, 7, 1] sage: list(tester.some_elements(repeat=2)) [(1, 4), (3, 1), (4, 5), (5, 0)] Test for :trac:`15919`, :trac:`16244`:: sage: Z = IntegerModRing(25) # random.sample, which was used pre #16244, has a threshold at 21! sage: Z[1] # since #8389, indexed access is used for ring extensions Traceback (most recent call last): ... ValueError: variable name '1' does not start with a letter sage: tester = InstanceTester(Z, elements=Z, max_runs=5) sage: list(tester.some_elements()) [0, 1, 2, 3, 4] sage: C = cartesian_product([Z]*4) sage: len(C) 390625 sage: tester = InstanceTester(C, elements = C, max_runs=4) sage: list(tester.some_elements()) [(0, 0, 0, 0), (0, 0, 0, 1), (0, 0, 0, 2), (0, 0, 0, 3)] """ S = S or self._elements or self._instance.some_elements() from sage.misc.misc import some_tuples return list(some_tuples(S, repeat, self._max_runs, self._max_samples))
def _test_jacobi(self, **options): """ Test the Jacobi axiom of this Lie conformal algebra. INPUT: - ``options`` -- any keyword arguments acceptde by :meth:`_tester` EXAMPLES: By default, this method tests only the elements returned by ``self.some_elements()``:: sage: V = lie_conformal_algebras.Affine(QQ, 'B2') sage: V._test_jacobi() # long time (6 seconds) It works for super Lie conformal algebras too:: sage: V = lie_conformal_algebras.NeveuSchwarz(QQ) sage: V._test_jacobi() We can use specific elements by passing the ``elements`` keyword argument:: sage: V = lie_conformal_algebras.Affine(QQ, 'A1', names=('e', 'h', 'f')) sage: V.inject_variables() Defining e, h, f, K sage: V._test_jacobi(elements=(e, 2*f+h, 3*h)) TESTS:: sage: wrongdict = {('a', 'a'): {0: {('b', 0): 1}}, ('b', 'a'): {0: {('a', 0): 1}}} sage: V = LieConformalAlgebra(QQ, wrongdict, names=('a', 'b'), parity=(1, 0)) sage: V._test_jacobi() Traceback (most recent call last): ... AssertionError: {(0, 0): -3*a} != {} - {(0, 0): -3*a} + {} """ tester = self._tester(**options) S = tester.some_elements() from sage.misc.misc import some_tuples from sage.arith.misc import binomial pz = tester._instance.zero() for x, y, z in some_tuples(S, 3, tester._max_runs): brxy = x.bracket(y) brxz = x.bracket(z) bryz = y.bracket(z) br1 = {k: x.bracket(v) for k, v in bryz.items()} br2 = {k: v.bracket(z) for k, v in brxy.items()} br3 = {k: y.bracket(v) for k, v in brxz.items()} jac1 = {(j, k): v for k in br1 for j, v in br1[k].items()} jac3 = {(k, j): v for k in br3 for j, v in br3[k].items()} jac2 = {} for k, br in br2.items(): for j, v in br.items(): for r in range(j + 1): jac2[(k + r, j - r)] = (jac2.get( (k + r, j - r), pz) + binomial(k + r, r) * v) for k, v in jac2.items(): jac1[k] = jac1.get(k, pz) - v for k, v in jac3.items(): jac1[k] = jac1.get(k, pz) - v jacobiator = {k: v for k, v in jac1.items() if v} tester.assertDictEqual(jacobiator, {})