improve fq_default and raise coverage of tests

Author: GiacomoPope

src/flint/test/test_all.py

@@ -3671,15 +3671,44 @@ def test_matrices_transpose():
 
 def test_fq_default():
     # test fq_default context creation
-    # TODO
+
+    # fq_type parsing
+    assert raises(lambda: flint.fq_default_ctx(5, fq_type="A"), ValueError)
+    assert raises(lambda: flint.fq_default_ctx(5, fq_type=[]), TypeError)
+    assert raises(lambda: flint.fq_default_ctx(5, fq_type=-1), ValueError)
+
+    # var must be one character
+    assert raises(lambda: flint.fq_default_ctx(5, var="XXX"), ValueError)
+
+    # p must be set if modulus has no characteristic / modulus
+    assert raises(lambda: flint.fq_default_ctx(modulus=[0,1,0]), ValueError)
+
+    # prime must be prime when setting from modulus
+    assert raises(lambda: flint.fq_default_ctx(10, modulus=[0,1,0]), ValueError)
+    mod_not_prime = flint.fmpz_mod_poly_ctx(10)([1,0,1])
+    assert raises(lambda: flint.fq_default_ctx(modulus=mod_not_prime), ValueError)
+    mod_not_irr = flint.fmpz_mod_poly_ctx(11)([0,0,1])
+    assert raises(lambda: flint.fq_default_ctx(modulus=mod_not_irr), ValueError)
+
+    # modulus must be able to be cast to fmpz_mod_poly
+    assert raises(lambda: flint.fq_default_ctx(11, modulus="AAA"), TypeError)
+
+    # either p or modulus must be set
+    assert raises(lambda: flint.fq_default_ctx(p=None, modulus=None), ValueError)
+
+    # p must be prime
+    assert raises(lambda: flint.fq_default_ctx(10), ValueError)
+    
+    # degree must be positive
+    assert raises(lambda: flint.fq_default_ctx(11, -1), ValueError)
 
     # GF(5)
-    gf_5 = flint.fq_default_ctx(5)
-    gf_5_ = flint.fq_default_ctx(5)
+    gf_5 = flint.fq_default_ctx(5, fq_type='NMOD')
+    gf_5_ = flint.fq_default_ctx(5, fq_type='NMOD')
 
     # GF(5^2)
-    gf_5_2 = flint.fq_default_ctx(5, 2)
-    gf_5_2_ = flint.fq_default_ctx(5, 2)
+    gf_5_2 = flint.fq_default_ctx(5, 2, fq_type='FQ_ZECH')
+    gf_5_2_ = flint.fq_default_ctx(5, 2, fq_type='FQ_ZECH')
 
     # GF((2**127 - 1)^2)
     gf_127 = flint.fq_default_ctx(2**127 - 1, 2)
@@ -3689,6 +3718,8 @@ def test_fq_default():
     assert (gf_5 != gf_5_) is False
     assert (gf_5 == gf_5_2) is False
     assert (gf_5 != gf_5_2) is True
+    assert (gf_5 == "a") is False
+    assert (gf_5 != "a") is True
 
     assert gf_5.prime() == gf_5_2.prime() == 5
     assert gf_5_2.order() == 5*5
@@ -3702,7 +3733,11 @@ def test_fq_default():
     assert str(gf_5) == "Context for fq_default in GF(5)"
     assert str(gf_5_2) == "Context for fq_default in GF(5^2)[z]/(z^2 + 4*z + 2)"
 
+    assert repr(gf_5) == "fq_default_ctx(5, var='z' type='NMOD')"
+    assert repr(gf_5_2) == "fq_default_ctx(5, 2, 'z', x^2 + 4*x + 2, 'FQ_ZECH')"
+
     # coercision
+    assert gf_5.one() == flint.fq_default(1, gf_5)
     assert gf_5(1) == gf_5.one()
     assert gf_5(flint.fmpz(1)) == gf_5.one()
     assert gf_5(-1) == -gf_5.one()
@@ -3717,7 +3752,10 @@ def test_fq_default():
     R = flint.fmpz_mod_poly_ctx(5)
     assert gf_5.gen() == gf_5(R.gen())
     assert gf_5.gen() == gf_5(flint.nmod_poly([0, 1], 5))
-
+    assert gf_5(flint.fmpz(2**64)) == gf_5(2**64)
+    assert raises(lambda: flint.fq_default(1, "AAA"), TypeError)
+    assert raises(lambda: flint.fq_default.__init__(1, "AAA"), TypeError)
+    assert raises(lambda: flint.fq_default("AAA", gf_5), TypeError)
 
     # testing various equalties between types
 
@@ -3809,6 +3847,7 @@ def test_fq_default():
         assert (a / b) / c == a / (b * c)
 
         assert a + 0 == 0 + a == a
+        assert a - 0 == -(0 - a) == a
         assert a + gf.zero() == a
         assert a * 1 == 1 * a == a
         assert a * gf.one() == a
@@ -3818,13 +3857,21 @@ def test_fq_default():
         assert raises(lambda: a / 0, ZeroDivisionError)
         assert raises(lambda: ~gf.zero(), ZeroDivisionError)
         assert raises(lambda: pow(gf.zero(), -1), ZeroDivisionError)
+        assert raises(lambda: pow(gf.zero(), "A"), TypeError)
 
         assert 1/a == pow(a, -1) == ~a
         assert gf.one() == pow(a, 0)
         assert gf.zero() == pow(gf.zero(), 2**64)
         assert a == pow(a, 1)
-
+        assert pow(a, flint.fmpz(2**64)) == pow(a, 2**64)
         assert (a*a).is_square()
+        assert (a*a).sqrt() in [a, -a]
+
+        while True:
+            nqr = gf.random_element()
+            if not nqr.is_square():
+                break
+        assert raises(lambda: nqr.sqrt(), ValueError)
 
 
 def test_fq_default_poly():

src/flint/types/fq_default.pxd

@@ -34,10 +34,7 @@ cdef class fq_default_ctx:
     cdef any_as_fq_default(self, obj)
 
     cdef _set_from_order(self, p, d, var, fq_type=*, check_prime=*)
-    cdef _set_from_modulus(self, modulus, var, fq_type=*, check_modulus=*)
-
-    cdef _c_set_from_order(self, fmpz p, int d, char *var, fq_default_type fq_type=*)
-    cdef _c_set_from_modulus(self, modulus, char *var, fq_default_type fq_type=*)
+    cdef _set_from_modulus(self, modulus, var, fq_type=*, check_prime=*, check_modulus=*)
 
 cdef class fq_default(flint_scalar):
     cdef fq_default_ctx ctx

src/flint/types/fq_default.pyx

@@ -76,10 +76,11 @@ cdef class fq_default_ctx:
 
         return var
 
-    def __init__(self, p=None, degree=None, var=None, modulus=None, fq_type=fq_default_type.DEFAULT):
+    def __init__(self, p=None, degree=None, var=None, modulus=None, fq_type=fq_default_type.DEFAULT,
+                 check_prime=True, check_modulus=True):
         # Ensure the var used for the generator of GF(p^d) is a single byte
-        # TODO: this var is meaningless for GF(p) -- we could handle this somehow?
         var = self._parse_input_var(var)
+        self.var = var
 
         # Ensure the fq_type is an integer between 0, 5 -- we allow users to
         # input a string which is converted as an enum
@@ -89,16 +90,17 @@ cdef class fq_default_ctx:
         if modulus is not None:
             # If the polynomial has no known characteristic, we can try and create one
             # using the supplied prime
-            if not (typecheck(modulus, fmpz_mod_poly) or typecheck(modulus, nmod_poly)):
+            if not typecheck(modulus, fmpz_mod_poly):
                 if p is None:
                     raise ValueError("cannot create from modulus if no characteristic is known")
-
                 ring_ctx = fmpz_mod_poly_ctx(p)
+                if not ring_ctx.is_prime():
+                    raise ValueError("characteristic is not prime")
                 modulus = ring_ctx.any_as_fmpz_mod_poly(modulus)
                 if modulus is NotImplemented:
                     raise TypeError("modulus cannot be cast to fmpz_mod_poly")
 
-            self._set_from_modulus(modulus, var, fq_type)
+            self._set_from_modulus(modulus, var, fq_type, check_prime=check_prime, check_modulus=check_modulus)
             return
 
         # If there's no modulus and no prime, we can't continue
@@ -110,23 +112,16 @@ cdef class fq_default_ctx:
             degree = 1
 
         # Construct the field from the prime and degree GF(p^d)
-        self._set_from_order(p, degree, var, fq_type)
+        self._set_from_order(p, degree, var, fq_type, check_prime=check_prime)
 
-    cdef _c_set_from_order(self, fmpz p, int d, char *var,
-                           fq_default_type fq_type=fq_default_type.DEFAULT):
-        self.var = var
-        fq_default_ctx_init_type(self.val, p.val, d, self.var, fq_type)
-        self._initialized = True
-
-    cdef _set_from_order(self, p, d, var,
-                       fq_type=fq_default_type.DEFAULT, check_prime=True):
+    cdef _set_from_order(self, p, d, var, fq_type=fq_default_type.DEFAULT, check_prime=True):
         """
         Construct a context for the finite field GF(p^d).
 
         `var` is a name for the ring generator of this field over GF(p).
 
         The optional parameter `type` select the implementation. For more
-        information about the types available, see :class:`~.fq_default_type` 
+        information about the types available, see :class:`~.fq_default_type`
         for possible types.
         """
         # c_from_order expects the characteristic to be fmpz type
@@ -141,24 +136,11 @@ cdef class fq_default_ctx:
         if d < 1:
             raise ValueError(f"the degree must be positive, got {d = }")
 
-        # Cython type conversion and context initalisation
-        self._c_set_from_order(prime, d, var, fq_type)
-
-    cdef _c_set_from_modulus(self, modulus, char *var,
-                             fq_default_type fq_type=fq_default_type.DEFAULT):
-        self.var = var
-        if typecheck(modulus, fmpz_mod_poly):
-            fq_default_ctx_init_modulus_type(self.val, (<fmpz_mod_poly>modulus).val,
-                                             (<fmpz_mod_poly>modulus).ctx.mod.val, self.var, fq_type)
-        elif typecheck(modulus, nmod_poly):
-            fq_default_ctx_init_modulus_nmod_type(self.val, (<nmod_poly>modulus).val,
-                                                  self.var, fq_type)
-        else:
-            raise TypeError(f"modulus must be fmpz_mod_poly or nmod_poly, got {modulus!r}")
+        fq_default_ctx_init_type(self.val, (<fmpz>prime).val, d, self.var, <fq_default_type>fq_type)
         self._initialized = True
 
-    cdef _set_from_modulus(self, modulus, var,
-                         fq_type=fq_default_type.DEFAULT, check_modulus=True):
+    cdef _set_from_modulus(self, modulus, var, fq_type=fq_default_type.DEFAULT,
+                           check_prime=True, check_modulus=True):
         """
         Construct a context for a finite field from an irreducible polynomial.
 
@@ -167,14 +149,18 @@ cdef class fq_default_ctx:
         `var` is a name for the ring generator of this field over the prime field.
 
         The optional parameter `type` select the implementation. For more
-        information about the types available, see :class:`~.fq_default_type` 
+        information about the types available, see :class:`~.fq_default_type`
         for possible types.
         """
+        if check_prime and not (<fmpz_mod_poly>modulus).ctx.is_prime():
+            raise ValueError("characteristic is not prime")
+
         if check_modulus and not modulus.is_irreducible():
             raise ValueError("modulus must be irreducible")
 
-        # Cython type conversion and context initalisation
-        self._c_set_from_modulus(modulus, var, fq_type)
+        fq_default_ctx_init_modulus_type(self.val, (<fmpz_mod_poly>modulus).val,
+                                         (<fmpz_mod_poly>modulus).ctx.mod.val, self.var, <fq_default_type>fq_type)
+        self._initialized = True
 
     @property
     def fq_type(self):
@@ -517,9 +503,6 @@ cdef class fq_default(flint_scalar):
     def str(self):
         return self.polynomial().str(var=self.ctx.var.decode())
 
-    def repr(self):
-        return f"fq_default({self.to_list(), self.ctx.__repr__()})"
-
     def __hash__(self):
         return hash((self.polynomial(), hash(self.ctx)))
 
@@ -741,11 +724,8 @@ cdef class fq_default(flint_scalar):
             fq_default_pow_ui(res.val, res.val, <ulong>e, self.ctx.val)
             return res
 
-        # Attempt to cast the exponent to an fmpz type then exponentiate
+        # Cast the exponent to fmpz type
         e_fmpz = any_as_fmpz(e)
-        if e_fmpz is NotImplemented:
-            raise TypeError(f"exponent {e = } cannot be cast to fmpz")
-
         fq_default_pow(res.val, res.val, (<fmpz>e_fmpz).val, self.ctx.val)
 
         return res