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_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_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_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, {})
