diff --git a/src/sage/categories/pushout.py b/src/sage/categories/pushout.py
index e8eee82998d..ed385eabbf1 100644
--- a/src/sage/categories/pushout.py
+++ b/src/sage/categories/pushout.py
@@ -3359,7 +3359,12 @@ def __init__(self, polys, names, embeddings=None, structures=None,
                 if latex_names[i] == latex_variable_name(name):
                     latex_names[i] = None
         self.latex_names = latex_names
-        self.kwds = kwds
+        kwds_self = dict(kwds.items())
+        if 'implementation' in kwds_self:
+            assert len(self.polys) == 1
+            self.implementations = [kwds_self['implementation']]
+            del kwds_self['implementation']
+        self.kwds = kwds_self
 
     def _apply_functor(self, R):
         """
@@ -3596,11 +3601,7 @@ def merge(self, other):
         # integers to encode degrees of extensions.
         from sage.rings.integer import Integer
         kwds_self = dict(self.kwds.items())
-        if 'impl' in kwds_self:
-            del kwds_self['impl']
         kwds_other = dict(other.kwds.items())
-        if 'impl' in kwds_other:
-            del kwds_other['impl']
         if (isinstance(self.polys[0], Integer)
                 and isinstance(other.polys[0], Integer)
                 and self.embeddings == other.embeddings == [None]
diff --git a/src/sage/homology/homology_vector_space_with_basis.py b/src/sage/homology/homology_vector_space_with_basis.py
index ace9775d56b..7ad9e3d9c58 100644
--- a/src/sage/homology/homology_vector_space_with_basis.py
+++ b/src/sage/homology/homology_vector_space_with_basis.py
@@ -1447,7 +1447,7 @@ def is_GF2(R):
         sage: from sage.homology.homology_vector_space_with_basis import is_GF2
         sage: is_GF2(GF(2))
         True
-        sage: is_GF2(GF(2, impl='ntl'))
+        sage: is_GF2(GF(2, implementation='ntl'))
         True
         sage: is_GF2(GF(3))
         False
diff --git a/src/sage/modules/free_module_element.pyx b/src/sage/modules/free_module_element.pyx
index c93c71f195e..805f521d5aa 100644
--- a/src/sage/modules/free_module_element.pyx
+++ b/src/sage/modules/free_module_element.pyx
@@ -1015,7 +1015,7 @@ cdef class FreeModuleElement(Vector):   # abstract base class
         Create the multiplication table of `GF(4)` using GP::
 
             sage: # needs sage.libs.pari
-            sage: k.<a> = GF(4, impl="pari_ffelt")
+            sage: k.<a> = GF(4, implementation="pari_ffelt")
             sage: v = gp(vector(list(k)))
             sage: v
             [0, 1, a, a + 1]
diff --git a/src/sage/rings/finite_rings/element_base.pyx b/src/sage/rings/finite_rings/element_base.pyx
index f6a450edfa2..aa30f0f1ff4 100755
--- a/src/sage/rings/finite_rings/element_base.pyx
+++ b/src/sage/rings/finite_rings/element_base.pyx
@@ -740,15 +740,15 @@ cdef class FinitePolyExtElement(FiniteRingElement):
 
         EXAMPLES::
 
-            sage: k.<a> = FiniteField(9, impl='givaro', modulus='primitive')            # needs sage.libs.linbox
+            sage: k.<a> = FiniteField(9, implementation='givaro', modulus='primitive')            # needs sage.libs.linbox
             sage: a.is_square()                                                         # needs sage.libs.linbox
             False
             sage: (a**2).is_square()                                                    # needs sage.libs.linbox
             True
-            sage: k.<a> = FiniteField(4, impl='ntl', modulus='primitive')               # needs sage.libs.ntl
+            sage: k.<a> = FiniteField(4, implementation='ntl', modulus='primitive')               # needs sage.libs.ntl
             sage: (a**2).is_square()                                                    # needs sage.libs.ntl
             True
-            sage: k.<a> = FiniteField(17^5, impl='pari_ffelt', modulus='primitive')     # needs sage.libs.pari
+            sage: k.<a> = FiniteField(17^5, implementation='pari_ffelt', modulus='primitive')     # needs sage.libs.pari
             sage: a.is_square()                                                         # needs sage.libs.pari
             False
             sage: (a**2).is_square()                                                    # needs sage.libs.pari
@@ -799,7 +799,7 @@ cdef class FinitePolyExtElement(FiniteRingElement):
             3
             sage: F(4).square_root()
             2
-            sage: K = FiniteField(7^3, 'alpha', impl='pari_ffelt')
+            sage: K = FiniteField(7^3, 'alpha', implementation='pari_ffelt')
             sage: K(3).square_root()
             Traceback (most recent call last):
             ...
diff --git a/src/sage/rings/finite_rings/element_givaro.pyx b/src/sage/rings/finite_rings/element_givaro.pyx
index c9b9e323181..9d56663fcb0 100644
--- a/src/sage/rings/finite_rings/element_givaro.pyx
+++ b/src/sage/rings/finite_rings/element_givaro.pyx
@@ -585,12 +585,12 @@ cdef class Cache_givaro(Cache_base):
             sage: k._cache._element_repr(a^20)
             '2*a^3 + 2*a^2 + 2'
 
-            sage: k = FiniteField(3^4,'a', impl='givaro', repr='int')
+            sage: k = FiniteField(3^4,'a', implementation='givaro', repr='int')
             sage: a = k.gen()
             sage: k._cache._element_repr(a^20)
             '74'
 
-            sage: k = FiniteField(3^4,'a', impl='givaro', repr='log')
+            sage: k = FiniteField(3^4,'a', implementation='givaro', repr='log')
             sage: a = k.gen()
             sage: k._cache._element_repr(a^20)
             '20'
diff --git a/src/sage/rings/finite_rings/element_ntl_gf2e.pyx b/src/sage/rings/finite_rings/element_ntl_gf2e.pyx
index 399bb76815b..50f665ca375 100644
--- a/src/sage/rings/finite_rings/element_ntl_gf2e.pyx
+++ b/src/sage/rings/finite_rings/element_ntl_gf2e.pyx
@@ -144,7 +144,7 @@ cdef class Cache_ntl_gf2e(Cache_base):
 
         TESTS::
 
-            sage: k.<a> = GF(2^8, impl="ntl")
+            sage: k.<a> = GF(2^8, implementation="ntl")
         """
         self._parent = <FiniteField?>parent
         self._zero_element = self._new()
@@ -262,10 +262,10 @@ cdef class Cache_ntl_gf2e(Cache_base):
 
         We can coerce from PARI finite field implementations::
 
-            sage: K.<a> = GF(2^19, impl="ntl")
+            sage: K.<a> = GF(2^19, implementation="ntl")
             sage: a^20
             a^6 + a^3 + a^2 + a
-            sage: M.<c> = GF(2^19, impl="pari_ffelt")
+            sage: M.<c> = GF(2^19, implementation="pari_ffelt")
             sage: K(c^20)
             a^6 + a^3 + a^2 + a
         """
@@ -503,7 +503,7 @@ cdef class FiniteField_ntl_gf2eElement(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: k.<a> = GF(2^8, impl="ntl") # indirect doctest
+            sage: k.<a> = GF(2^8, implementation="ntl") # indirect doctest
         """
         if parent is None:
             return
@@ -1005,7 +1005,7 @@ cdef class FiniteField_ntl_gf2eElement(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: k.<a> = GF(2^8, impl="ntl")
+            sage: k.<a> = GF(2^8, implementation="ntl")
             sage: b = a^3 + a
             sage: b.minpoly()
             x^4 + x^3 + x^2 + x + 1
diff --git a/src/sage/rings/finite_rings/element_pari_ffelt.pyx b/src/sage/rings/finite_rings/element_pari_ffelt.pyx
index 989b0e20b9e..371a6830973 100644
--- a/src/sage/rings/finite_rings/element_pari_ffelt.pyx
+++ b/src/sage/rings/finite_rings/element_pari_ffelt.pyx
@@ -93,7 +93,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
     EXAMPLES::
 
-        sage: K = FiniteField(10007^10, 'a', impl='pari_ffelt')
+        sage: K = FiniteField(10007^10, 'a', implementation='pari_ffelt')
         sage: a = K.gen(); a
         a
         sage: type(a)
@@ -103,7 +103,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         sage: n = 63
         sage: m = 3
-        sage: K.<a> = GF(2^n, impl='pari_ffelt')
+        sage: K.<a> = GF(2^n, implementation='pari_ffelt')
         sage: f = conway_polynomial(2, n)
         sage: f(a) == 0
         True
@@ -111,7 +111,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
         sage: conway_polynomial(2, m)(a^e) == 0
         True
 
-        sage: K.<a> = FiniteField(2^16, impl='pari_ffelt')
+        sage: K.<a> = FiniteField(2^16, implementation='pari_ffelt')
         sage: K(0).is_zero()
         True
         sage: (a - a).is_zero()
@@ -128,13 +128,13 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
     Test creating elements from basic Python types::
 
-        sage: K.<a> = FiniteField(7^20, impl='pari_ffelt')
+        sage: K.<a> = FiniteField(7^20, implementation='pari_ffelt')
         sage: K(int(8))
         1
 
     ::
 
-        sage: k = FiniteField(3^4, 'a', impl='pari_ffelt')
+        sage: k = FiniteField(3^4, 'a', implementation='pari_ffelt')
         sage: b = k(5) # indirect doctest
         sage: b.parent()
         Finite Field in a of size 3^4
@@ -146,7 +146,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
     the polynomial at the field's generator::
 
         sage: R.<x> = QQ[]
-        sage: k.<a> = FiniteField(5^2, 'a', impl='pari_ffelt')
+        sage: k.<a> = FiniteField(5^2, 'a', implementation='pari_ffelt')
         sage: k(R(2/3))
         4
         sage: k(x^2)
@@ -160,13 +160,13 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
         sage: k(x^25)
         a
 
-        sage: Q.<q> = FiniteField(5^7, 'q', impl='pari_ffelt')
+        sage: Q.<q> = FiniteField(5^7, 'q', implementation='pari_ffelt')
         sage: L = GF(5)
         sage: LL.<xx> = L[]
         sage: Q(xx^2 + 2*xx + 4)
         q^2 + 2*q + 4
 
-        sage: k = FiniteField(3^11, 't', impl='pari_ffelt')
+        sage: k = FiniteField(3^11, 't', implementation='pari_ffelt')
         sage: k.polynomial()
         t^11 + 2*t^2 + 1
         sage: P = k.polynomial_ring()
@@ -176,7 +176,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
     An element can be specified by its vector of coordinates with
     respect to the basis consisting of powers of the generator:
 
-        sage: k = FiniteField(3^11, 't', impl='pari_ffelt')
+        sage: k = FiniteField(3^11, 't', implementation='pari_ffelt')
         sage: V = k.vector_space(map=False)
         sage: V
         Vector space of dimension 11 over Finite Field of size 3
@@ -186,7 +186,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
     Multivariate polynomials only coerce if constant::
 
-        sage: k = FiniteField(5^2, 'a', impl='pari_ffelt')
+        sage: k = FiniteField(5^2, 'a', implementation='pari_ffelt')
         sage: R = k['x,y,z']; R
         Multivariate Polynomial Ring in x, y, z over Finite Field in a of size 5^2
         sage: k(R(2))
@@ -199,7 +199,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
     Gap elements can also be coerced into finite fields::
 
-        sage: F = FiniteField(2^3, 'a', impl='pari_ffelt')
+        sage: F = FiniteField(2^3, 'a', implementation='pari_ffelt')
         sage: a = F.multiplicative_generator(); a
         a
         sage: b = gap(a^3); b                                                           # needs sage.libs.gap
@@ -214,7 +214,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
         sage: a.parent()
         Finite Field of size 13
 
-        sage: F = FiniteField(2^4, 'a', impl='pari_ffelt')
+        sage: F = FiniteField(2^4, 'a', implementation='pari_ffelt')
         sage: F(gap('Z(16)^3'))                                                         # needs sage.libs.gap
         a^3
         sage: F(gap('Z(16)^2'))                                                         # needs sage.libs.gap
@@ -231,7 +231,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
     TESTS::
 
-        sage: k = FiniteField(3^2, 'a', impl='pari_ffelt')
+        sage: k = FiniteField(3^2, 'a', implementation='pari_ffelt')
         sage: a = k(11); a
         2
         sage: a.parent()
@@ -243,7 +243,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
     We create elements using a list and verify that :issue:`10486` has
     been fixed::
 
-        sage: k = FiniteField(3^11, 't', impl='pari_ffelt')
+        sage: k = FiniteField(3^11, 't', implementation='pari_ffelt')
         sage: x = k([1,0,2,1]); x
         t^3 + 2*t^2 + 1
         sage: x + x + x
@@ -265,7 +265,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
     When initializing from a list, the elements are first coerced
     to the prime field (:issue:`11685`)::
 
-        sage: k = FiniteField(3^11, 't', impl='pari_ffelt')
+        sage: k = FiniteField(3^11, 't', implementation='pari_ffelt')
         sage: k([ 0, 1/2 ])
         2*t
         sage: k([ 0, 1/2, 0, 0, 0, 0, 0, 0, 0, -1, 0 ])
@@ -284,7 +284,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
     Check that zeros are created correctly (:issue:`11685`)::
 
-        sage: K = FiniteField(3^11, 't', impl='pari_ffelt'); a = K.0
+        sage: K = FiniteField(3^11, 't', implementation='pari_ffelt'); a = K.0
         sage: v = 0; pari(K(v))
         0
         sage: v = Mod(0,3); pari(K(v))
@@ -329,7 +329,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
         TESTS::
 
             sage: from sage.rings.finite_rings.element_pari_ffelt import FiniteFieldElement_pari_ffelt
-            sage: K = FiniteField(101^2, 'a', impl='pari_ffelt')
+            sage: K = FiniteField(101^2, 'a', implementation='pari_ffelt')
             sage: x = FiniteFieldElement_pari_ffelt(K, 'a + 1')
             sage: x
             a + 1
@@ -537,7 +537,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: k.<c> = GF(3^17, impl='pari_ffelt')
+            sage: k.<c> = GF(3^17, implementation='pari_ffelt')
             sage: c^20  # indirect doctest
             c^4 + 2*c^3
         """
@@ -550,7 +550,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: k.<a> = GF(3^15, impl='pari_ffelt')
+            sage: k.<a> = GF(3^15, implementation='pari_ffelt')
             sage: R = GF(3)['a']; aa = R.gen()
             sage: hash(a^2 + 1) == hash(aa^2 + 1)
             True
@@ -563,7 +563,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         TESTS::
 
-            sage: K.<a> = FiniteField(10007^10, impl='pari_ffelt')
+            sage: K.<a> = FiniteField(10007^10, implementation='pari_ffelt')
             sage: loads(a.dumps()) == a
             True
         """
@@ -573,7 +573,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
         """
         TESTS::
 
-            sage: k.<a> = FiniteField(3^3, impl='pari_ffelt')
+            sage: k.<a> = FiniteField(3^3, implementation='pari_ffelt')
             sage: a
             a
             sage: b = copy(a); b
@@ -588,7 +588,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
         """
         TESTS::
 
-            sage: k.<a> = FiniteField(3^3, impl='pari_ffelt')
+            sage: k.<a> = FiniteField(3^3, implementation='pari_ffelt')
             sage: a
             a
             sage: b = deepcopy(a); b
@@ -612,7 +612,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
         EXAMPLES::
 
             sage: # needs sage.modules
-            sage: k.<a> = GF(2^20, impl='pari_ffelt')
+            sage: k.<a> = GF(2^20, implementation='pari_ffelt')
             sage: e = k.random_element()
             sage: f = loads(dumps(e))
             sage: e is f
@@ -624,7 +624,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         ::
 
-            sage: K.<a> = GF(2^100, impl='pari_ffelt')
+            sage: K.<a> = GF(2^100, implementation='pari_ffelt')
             sage: a < a^2
             True
             sage: a > a^2
@@ -642,7 +642,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         TESTS::
 
-            sage: k.<a> = FiniteField(3^3, impl='pari_ffelt')
+            sage: k.<a> = FiniteField(3^3, implementation='pari_ffelt')
             sage: a == 1
             False
             sage: a^0 == 1
@@ -666,7 +666,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: k.<a> = GF(3^17, impl='pari_ffelt')
+            sage: k.<a> = GF(3^17, implementation='pari_ffelt')
             sage: a + a^2 # indirect doctest
             a^2 + a
         """
@@ -682,7 +682,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: k.<a> = GF(3^17, impl='pari_ffelt')
+            sage: k.<a> = GF(3^17, implementation='pari_ffelt')
             sage: a - a # indirect doctest
             0
         """
@@ -698,7 +698,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: k.<a> = GF(3^17, impl='pari_ffelt')
+            sage: k.<a> = GF(3^17, implementation='pari_ffelt')
             sage: (a^12 + 1)*(a^15 - 1) # indirect doctest
             a^15 + 2*a^12 + a^11 + 2*a^10 + 2
         """
@@ -714,7 +714,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: k.<a> = GF(3^17, impl='pari_ffelt')
+            sage: k.<a> = GF(3^17, implementation='pari_ffelt')
             sage: (a - 1) / (a + 1) # indirect doctest
             2*a^16 + a^15 + 2*a^14 + a^13 + 2*a^12 + a^11 + 2*a^10 + a^9 + 2*a^8 + a^7 + 2*a^6 + a^5 + 2*a^4 + a^3 + 2*a^2 + a + 1
         """
@@ -732,7 +732,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: F.<a> = FiniteField(5^3, impl='pari_ffelt')
+            sage: F.<a> = FiniteField(5^3, implementation='pari_ffelt')
             sage: a.is_zero()
             False
             sage: (a - a).is_zero()
@@ -746,7 +746,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: F.<a> = FiniteField(5^3, impl='pari_ffelt')
+            sage: F.<a> = FiniteField(5^3, implementation='pari_ffelt')
             sage: a.is_one()
             False
             sage: (a/a).is_one()
@@ -760,7 +760,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: F.<a> = FiniteField(5^3, impl='pari_ffelt')
+            sage: F.<a> = FiniteField(5^3, implementation='pari_ffelt')
             sage: a.is_unit()
             True
         """
@@ -774,7 +774,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: k.<a> = GF(3^17, impl='pari_ffelt')
+            sage: k.<a> = GF(3^17, implementation='pari_ffelt')
             sage: +a
             a
         """
@@ -786,7 +786,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: k.<a> = GF(3^17, impl='pari_ffelt')
+            sage: k.<a> = GF(3^17, implementation='pari_ffelt')
             sage: -a
             2*a
         """
@@ -801,7 +801,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: k.<a> = FiniteField(3^2, impl='pari_ffelt')
+            sage: k.<a> = FiniteField(3^2, implementation='pari_ffelt')
             sage: ~a
             a + 2
             sage: (a+1)*a
@@ -822,7 +822,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         TESTS::
 
-            sage: K.<a> = GF(5^10, impl='pari_ffelt')
+            sage: K.<a> = GF(5^10, implementation='pari_ffelt')
             sage: n = (2*a)/a
             sage: n^-15
             2
@@ -875,7 +875,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
         TESTS::
 
             sage: # needs sage.modules
-            sage: F.<a> = GF(13^64, impl='pari_ffelt'); F
+            sage: F.<a> = GF(13^64, implementation='pari_ffelt'); F
             Finite Field in a of size 13^64
             sage: x = F.random_element()
             sage: x.pth_power(0) == x
@@ -888,7 +888,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
             True
 
             sage: # needs sage.modules
-            sage: F.<a> = GF(127^16, impl='pari_ffelt'); F
+            sage: F.<a> = GF(127^16, implementation='pari_ffelt'); F
             Finite Field in a of size 127^16
             sage: x = F.random_element()
             sage: x.pth_power(0) == x
@@ -930,7 +930,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: k.<a> = FiniteField(3^2, impl='pari_ffelt')
+            sage: k.<a> = FiniteField(3^2, implementation='pari_ffelt')
             sage: pol = a.polynomial()
             sage: pol
             a
@@ -939,7 +939,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         ::
 
-            sage: k = FiniteField(3^4, 'alpha', impl='pari_ffelt')
+            sage: k = FiniteField(3^4, 'alpha', implementation='pari_ffelt')
             sage: a = k.gen()
             sage: a.polynomial()
             alpha
@@ -965,7 +965,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
         EXAMPLES::
 
             sage: R.<x> = PolynomialRing(FiniteField(3))
-            sage: F.<a> = FiniteField(3^2, modulus=x^2 + 1, impl='pari_ffelt')
+            sage: F.<a> = FiniteField(3^2, modulus=x^2 + 1, implementation='pari_ffelt')
             sage: a.minpoly('y')
             y^2 + 1
         """
@@ -984,7 +984,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
         EXAMPLES::
 
             sage: R.<x> = PolynomialRing(FiniteField(3))
-            sage: F.<a> = FiniteField(3^2, modulus=x^2 + 1, impl='pari_ffelt')
+            sage: F.<a> = FiniteField(3^2, modulus=x^2 + 1, implementation='pari_ffelt')
             sage: a.charpoly('y')
             y^2 + 1
         """
@@ -999,17 +999,17 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: k.<a> = FiniteField(3^2, impl='pari_ffelt')
+            sage: k.<a> = FiniteField(3^2, implementation='pari_ffelt')
             sage: a.is_square()
             False
             sage: (a**2).is_square()
             True
 
-            sage: k.<a> = FiniteField(2^2, impl='pari_ffelt')
+            sage: k.<a> = FiniteField(2^2, implementation='pari_ffelt')
             sage: (a**2).is_square()
             True
 
-            sage: k.<a> = FiniteField(17^5, impl='pari_ffelt')
+            sage: k.<a> = FiniteField(17^5, implementation='pari_ffelt')
             sage: (a**2).is_square()
             True
             sage: a.is_square()
@@ -1054,7 +1054,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: F = FiniteField(7^2, 'a', impl='pari_ffelt')
+            sage: F = FiniteField(7^2, 'a', implementation='pari_ffelt')
             sage: F(2).sqrt()
             4
             sage: F(3).sqrt() in (2*F.gen() + 6, 5*F.gen() + 1)
@@ -1064,7 +1064,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
             sage: F(4).sqrt(all=True)
             [2, 5]
 
-            sage: K = FiniteField(7^3, 'alpha', impl='pari_ffelt')
+            sage: K = FiniteField(7^3, 'alpha', implementation='pari_ffelt')
             sage: K(3).sqrt()
             Traceback (most recent call last):
             ...
@@ -1072,7 +1072,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
             sage: K(3).sqrt(all=True)
             []
 
-            sage: K.<a> = GF(3^17, impl='pari_ffelt')
+            sage: K.<a> = GF(3^17, implementation='pari_ffelt')
             sage: (a^3 - a - 1).sqrt()
             a^16 + 2*a^15 + a^13 + 2*a^12 + a^10 + 2*a^9 + 2*a^8 + a^7 + a^6 + 2*a^5 + a^4 + 2*a^2 + 2*a + 2
         """
@@ -1120,7 +1120,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: F.<g> = FiniteField(2^10, impl='pari_ffelt')
+            sage: F.<g> = FiniteField(2^10, implementation='pari_ffelt')
             sage: b = g; a = g^37
             sage: a.log(b)
             37
@@ -1130,7 +1130,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         ::
 
-            sage: F.<a> = FiniteField(5^2, impl='pari_ffelt')
+            sage: F.<a> = FiniteField(5^2, implementation='pari_ffelt')
             sage: F(-1).log(F(2))
             2
             sage: F(1).log(a)
@@ -1155,7 +1155,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         Some cases where the logarithm is not defined or does not exist::
 
-            sage: F.<a> = GF(3^10, impl='pari_ffelt')
+            sage: F.<a> = GF(3^10, implementation='pari_ffelt')
             sage: a.log(-1)
             Traceback (most recent call last):
             ...
@@ -1215,7 +1215,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: a = FiniteField(5^3, 'a', impl='pari_ffelt').0
+            sage: a = FiniteField(5^3, 'a', implementation='pari_ffelt').0
             sage: a.multiplicative_order()
             124
             sage: a**124
@@ -1235,7 +1235,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: k = FiniteField(next_prime(10^10)^2, 'u', impl='pari_ffelt')
+            sage: k = FiniteField(next_prime(10^10)^2, 'u', implementation='pari_ffelt')
             sage: a = k(17)/k(19)
             sage: b = a.lift(); b
             7894736858
@@ -1256,7 +1256,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: k.<a> = GF(3^17, impl='pari_ffelt')
+            sage: k.<a> = GF(3^17, implementation='pari_ffelt')
             sage: b = k(2)
             sage: b._integer_()
             2
@@ -1273,7 +1273,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: k.<a> = GF(3^17, impl='pari_ffelt')
+            sage: k.<a> = GF(3^17, implementation='pari_ffelt')
             sage: b = k(2)
             sage: int(b)
             2
@@ -1290,7 +1290,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: k.<a> = GF(3^17, impl='pari_ffelt')
+            sage: k.<a> = GF(3^17, implementation='pari_ffelt')
             sage: b = k(2)
             sage: float(b)
             2.0
@@ -1303,7 +1303,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: k.<a> = FiniteField(3^3, impl='pari_ffelt')
+            sage: k.<a> = FiniteField(3^3, implementation='pari_ffelt')
             sage: b = a**2 + 2*a + 1
             sage: b.__pari__()
             a^2 + 2*a + 1
@@ -1316,7 +1316,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
 
         EXAMPLES::
 
-            sage: k.<a> = GF(3^17, impl='pari_ffelt')
+            sage: k.<a> = GF(3^17, implementation='pari_ffelt')
             sage: a._pari_init_()
             'subst(a+3*a,a,ffgen(Mod(1, 3)*x^17 + Mod(2, 3)*x + Mod(1, 3),a))'
             sage: k(1)._pari_init_()
@@ -1371,7 +1371,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
         EXAMPLES::
 
             sage: # needs sage.libs.gap
-            sage: F = FiniteField(2^3, 'aa', impl='pari_ffelt')
+            sage: F = FiniteField(2^3, 'aa', implementation='pari_ffelt')
             sage: aa = F.multiplicative_generator()
             sage: gap(aa)  # indirect doctest
             Z(2^3)
@@ -1389,7 +1389,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
         You can specify the instance of the Gap interpreter that is used::
 
             sage: # needs sage.libs.gap
-            sage: F = FiniteField(next_prime(200)^2, 'a', impl='pari_ffelt')
+            sage: F = FiniteField(next_prime(200)^2, 'a', implementation='pari_ffelt')
             sage: a = F.multiplicative_generator()
             sage: a._gap_ (gap)
             Z(211^2)
@@ -1399,7 +1399,7 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
         Gap only supports relatively small finite fields::
 
             sage: # needs sage.libs.gap
-            sage: F = FiniteField(next_prime(1000)^2, 'a', impl='pari_ffelt')
+            sage: F = FiniteField(next_prime(1000)^2, 'a', implementation='pari_ffelt')
             sage: a = F.multiplicative_generator()
             sage: a._gap_init_()
             Traceback (most recent call last):
@@ -1427,7 +1427,7 @@ def unpickle_FiniteFieldElement_pari_ffelt(parent, elem):
     EXAMPLES::
 
         sage: # needs sage.modules
-        sage: k.<a> = GF(2^20, impl='pari_ffelt')
+        sage: k.<a> = GF(2^20, implementation='pari_ffelt')
         sage: e = k.random_element()
         sage: f = loads(dumps(e)) # indirect doctest
         sage: e == f
diff --git a/src/sage/rings/finite_rings/finite_field_base.pyx b/src/sage/rings/finite_rings/finite_field_base.pyx
index 2c49f3bc9ae..e4a6c646ea1 100644
--- a/src/sage/rings/finite_rings/finite_field_base.pyx
+++ b/src/sage/rings/finite_rings/finite_field_base.pyx
@@ -123,7 +123,7 @@ cdef class FiniteField(Field):
             False
             sage: F == FiniteField(3^2, 'd')
             False
-            sage: F == FiniteField(3^2, 'c', impl='pari_ffelt')
+            sage: F == FiniteField(3^2, 'c', implementation='pari_ffelt')
             False
         """
         if self is other:
@@ -320,14 +320,14 @@ cdef class FiniteField(Field):
 
         EXAMPLES::
 
-            sage: k.<a> = FiniteField(9, impl="pari")
+            sage: k.<a> = FiniteField(9, implementation="pari")
             sage: list(k)
             [0, 1, 2, a, a + 1, a + 2, 2*a, 2*a + 1, 2*a + 2]
 
         Partial iteration of a very large finite field::
 
             sage: p = next_prime(2^64)
-            sage: k.<a> = FiniteField(p^2, impl="pari")
+            sage: k.<a> = FiniteField(p^2, implementation="pari")
             sage: it = iter(k); it
             <...generator object at ...>
             sage: [next(it) for i in range(10)]
@@ -339,11 +339,11 @@ cdef class FiniteField(Field):
 
             sage: L = []
             sage: from sage.rings.finite_rings.finite_field_base import FiniteField
-            sage: print(list(FiniteField.__iter__(GF(8, impl="givaro", names="z"))))    # needs sage.libs.linbox
+            sage: print(list(FiniteField.__iter__(GF(8, implementation="givaro", names="z"))))    # needs sage.libs.linbox
             [0, 1, z, z + 1, z^2, z^2 + 1, z^2 + z, z^2 + z + 1]
-            sage: print(list(FiniteField.__iter__(GF(8, impl="pari", names="z"))))
+            sage: print(list(FiniteField.__iter__(GF(8, implementation="pari", names="z"))))
             [0, 1, z, z + 1, z^2, z^2 + 1, z^2 + z, z^2 + z + 1]
-            sage: print(list(FiniteField.__iter__(GF(8, impl="ntl", names="z"))))       # needs sage.libs.ntl
+            sage: print(list(FiniteField.__iter__(GF(8, implementation="ntl", names="z"))))       # needs sage.libs.ntl
             [0, 1, z, z + 1, z^2, z^2 + 1, z^2 + z, z^2 + z + 1]
         """
         cdef Py_ssize_t n = self.degree()
@@ -1013,7 +1013,7 @@ cdef class FiniteField(Field):
 
         The given modulus is always made monic::
 
-            sage: k.<a> = GF(7^2, modulus=2*x^2 - 3, impl="pari_ffelt")
+            sage: k.<a> = GF(7^2, modulus=2*x^2 - 3, implementation="pari_ffelt")
             sage: k.modulus()
             x^2 + 2
 
@@ -1021,21 +1021,21 @@ cdef class FiniteField(Field):
 
         We test the various finite field implementations::
 
-            sage: GF(2, impl="modn").modulus()
+            sage: GF(2, implementation="modn").modulus()
             x + 1
-            sage: GF(2, impl="givaro").modulus()                                        # needs sage.libs.linbox
+            sage: GF(2, implementation="givaro").modulus()                                        # needs sage.libs.linbox
             x + 1
-            sage: GF(2, impl="ntl").modulus()                                           # needs sage.libs.ntl
+            sage: GF(2, implementation="ntl").modulus()                                           # needs sage.libs.ntl
             x + 1
-            sage: GF(2, impl="modn", modulus=x).modulus()
+            sage: GF(2, implementation="modn", modulus=x).modulus()
             x
-            sage: GF(2, impl="givaro", modulus=x).modulus()                             # needs sage.libs.linbox
+            sage: GF(2, implementation="givaro", modulus=x).modulus()                             # needs sage.libs.linbox
             x
-            sage: GF(2, impl="ntl", modulus=x).modulus()                                # needs sage.libs.ntl
+            sage: GF(2, implementation="ntl", modulus=x).modulus()                                # needs sage.libs.ntl
             x
-            sage: GF(13^2, 'a', impl="givaro", modulus=x^2 + 2).modulus()               # needs sage.libs.linbox
+            sage: GF(13^2, 'a', implementation="givaro", modulus=x^2 + 2).modulus()               # needs sage.libs.linbox
             x^2 + 2
-            sage: GF(13^2, 'a', impl="pari_ffelt", modulus=x^2 + 2).modulus()           # needs sage.libs.pari
+            sage: GF(13^2, 'a', implementation="pari_ffelt", modulus=x^2 + 2).modulus()           # needs sage.libs.pari
             x^2 + 2
         """
         # Normally, this is set by the constructor of the implementation
@@ -1077,18 +1077,18 @@ cdef class FiniteField(Field):
             sage: k.polynomial()
             a^2 + 2*a + 2
 
-            sage: F = FiniteField(9, 'a', impl='pari_ffelt')
+            sage: F = FiniteField(9, 'a', implementation='pari_ffelt')
             sage: F.polynomial()
             a^2 + 2*a + 2
 
-            sage: F = FiniteField(7^20, 'a', impl='pari_ffelt')
+            sage: F = FiniteField(7^20, 'a', implementation='pari_ffelt')
             sage: f = F.polynomial(); f
             a^20 + a^12 + 6*a^11 + 2*a^10 + 5*a^9 + 2*a^8 + 3*a^7 + a^6 + 3*a^5 + 3*a^3 + a + 3
             sage: f(F.gen())
             0
 
             sage: # needs sage.libs.ntl
-            sage: k.<a> = GF(2^20, impl='ntl')
+            sage: k.<a> = GF(2^20, implementation='ntl')
             sage: k.polynomial()
             a^20 + a^10 + a^9 + a^7 + a^6 + a^5 + a^4 + a + 1
             sage: k.polynomial('FOO')
@@ -1429,7 +1429,7 @@ cdef class FiniteField(Field):
 
         The implementation is taken into account, by :issue:`15223`::
 
-            sage: k = FiniteField(9, 'a', impl='pari_ffelt')
+            sage: k = FiniteField(9, 'a', implementation='pari_ffelt')
             sage: F, R = k.construction()
             sage: F(R) is k
             True
@@ -1437,7 +1437,7 @@ cdef class FiniteField(Field):
         """
         from sage.categories.pushout import AlgebraicExtensionFunctor
         try:
-            kwds = {'impl': self._factory_data[2][3]}
+            kwds = {'implementation': self._factory_data[2][3]}
         except (AttributeError, IndexError, TypeError):
             kwds = {}
         if self.degree() == 1:
diff --git a/src/sage/rings/finite_rings/finite_field_constructor.py b/src/sage/rings/finite_rings/finite_field_constructor.py
index 78acc0a8873..9963bc0c0c5 100644
--- a/src/sage/rings/finite_rings/finite_field_constructor.py
+++ b/src/sage/rings/finite_rings/finite_field_constructor.py
@@ -226,7 +226,7 @@ class FiniteFieldFactory(UniqueFactory):
       ``modulus="primitive"`` to get a primitive polynomial.  You
       may not specify a modulus if you do not specify a variable name.
 
-    - ``impl`` -- (optional) a string specifying the implementation of
+    - ``implementation`` -- (optional) a string specifying the implementation of
       the finite field. Possible values are:
 
       - ``'modn'`` -- ring of integers modulo `p` (only for prime
@@ -241,9 +241,9 @@ class FiniteFieldFactory(UniqueFactory):
         for extension fields).
 
     - ``elem_cache`` -- (default: order < 500) cache all elements to
-      avoid creation time; ignored unless ``impl='givaro'``
+      avoid creation time; ignored unless ``implementation='givaro'``
 
-    - ``repr`` -- (default: ``'poly'``) ignored unless ``impl='givaro'``;
+    - ``repr`` -- (default: ``'poly'``) ignored unless ``implementation='givaro'``;
       controls the way elements are printed to the user:
 
       - 'log': repr is
@@ -465,9 +465,9 @@ class FiniteFieldFactory(UniqueFactory):
 
     Check that :issue:`16934` has been fixed::
 
-        sage: k1.<a> = GF(17^14, impl="pari")
+        sage: k1.<a> = GF(17^14, implementation="pari")
         sage: _ = a/2
-        sage: k2.<a> = GF(17^14, impl="pari")
+        sage: k2.<a> = GF(17^14, implementation="pari")
         sage: k1 is k2
         True
 
@@ -501,8 +501,10 @@ def __init__(self, *args, **kwds):
         self._modulus_cache = defaultdict(dict)
         super().__init__(*args, **kwds)
 
+    from sage.misc.decorators import rename_keyword
+    @rename_keyword(deprecation=30507, impl='implementation')
     def create_key_and_extra_args(self, order, name=None, modulus=None, names=None,
-                                  impl=None, proof=None,
+                                  implementation=None, proof=None,
                                   check_prime=True, check_irreducible=True,
                                   prefix=None, repr=None, elem_cache=None,
                                   **kwds):
@@ -528,21 +530,21 @@ def create_key_and_extra_args(self, order, name=None, modulus=None, names=None,
         Moreover, ``repr`` and ``elem_cache`` are ignored when not
         using givaro::
 
-            sage: GF.create_key_and_extra_args(16, 'a', impl='ntl', repr='poly')        # needs sage.libs.ntl
+            sage: GF.create_key_and_extra_args(16, 'a', implementation='ntl', repr='poly')        # needs sage.libs.ntl
             ((16, ('a',), x^4 + x + 1, 'ntl', 2, 4, True, None, None, None, True, True), {})
-            sage: GF.create_key_and_extra_args(16, 'a', impl='ntl', elem_cache=False)   # needs sage.libs.ntl
+            sage: GF.create_key_and_extra_args(16, 'a', implementation='ntl', elem_cache=False)   # needs sage.libs.ntl
             ((16, ('a',), x^4 + x + 1, 'ntl', 2, 4, True, None, None, None, True, True), {})
-            sage: GF(16, impl='ntl') is GF(16, impl='ntl', repr='foo')                  # needs sage.libs.ntl
+            sage: GF(16, implementation='ntl') is GF(16, implementation='ntl', repr='foo')                  # needs sage.libs.ntl
             True
 
         We handle extra arguments for the givaro finite field and
         create unique objects for their defaults::
 
-            sage: GF(25, impl='givaro') is GF(25, impl='givaro', repr='poly')           # needs sage.libs.linbox
+            sage: GF(25, implementation='givaro') is GF(25, implementation='givaro', repr='poly')           # needs sage.libs.linbox
             True
-            sage: GF(25, impl='givaro') is GF(25, impl='givaro', elem_cache=True)       # needs sage.libs.linbox
+            sage: GF(25, implementation='givaro') is GF(25, implementation='givaro', elem_cache=True)       # needs sage.libs.linbox
             True
-            sage: GF(625, impl='givaro') is GF(625, impl='givaro', elem_cache=False)    # needs sage.libs.linbox
+            sage: GF(625, implementation='givaro') is GF(625, implementation='givaro', elem_cache=False)    # needs sage.libs.linbox
             True
 
         We explicitly take ``structure``, ``implementation`` and ``prec`` attributes
@@ -602,8 +604,8 @@ def create_key_and_extra_args(self, order, name=None, modulus=None, names=None,
             # note that we haven't tested p for primality
 
             if n == 1:
-                if impl is None:
-                    impl = 'modn'
+                if implementation is None:
+                    implementation = 'modn'
                 name = ('x',)  # Ignore name
                 # Every polynomial of degree 1 is irreducible
                 check_irreducible = False
@@ -625,19 +627,19 @@ def create_key_and_extra_args(self, order, name=None, modulus=None, names=None,
                     check_irreducible = False
                 name = normalize_names(1, name)
 
-                if impl is None:
+                if implementation is None:
                     if order < zech_log_bound and FiniteField_givaro is not None:
-                        impl = 'givaro'
+                        implementation = 'givaro'
                     elif p == 2 and FiniteField_ntl_gf2e is not None:
-                        impl = 'ntl'
+                        implementation = 'ntl'
                     else:
-                        impl = 'pari_ffelt'
+                        implementation = 'pari_ffelt'
 
             # Determine modulus.
             # For the 'modn' implementation, we use the following
             # optimization which we also need to avoid an infinite loop:
             # a modulus of None is a shorthand for x-1.
-            if modulus is not None or impl != 'modn':
+            if modulus is not None or implementation != 'modn':
                 from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
                 R = PolynomialRing(FiniteField(p), 'x')
                 if modulus is None:
@@ -655,15 +657,15 @@ def create_key_and_extra_args(self, order, name=None, modulus=None, names=None,
 
                     if modulus.degree() != n:
                         raise ValueError("the degree of the modulus does not equal the degree of the field")
-                # If modulus is x - 1 for impl="modn", set it to None
-                if impl == 'modn' and modulus.list() == [-1,1]:
+                # If modulus is x - 1 for implementation="modn", set it to None
+                if implementation == 'modn' and modulus.list() == [-1,1]:
                     modulus = None
             if modulus is None:
                 check_irreducible = False
 
             # Check extra arguments for givaro and setup their defaults
             # TODO: ntl takes a repr, but ignores it
-            if impl == 'givaro':
+            if implementation == 'givaro':
                 if repr is None:
                     repr = 'poly'
                 if elem_cache is None:
@@ -673,8 +675,9 @@ def create_key_and_extra_args(self, order, name=None, modulus=None, names=None,
                 repr = None
                 elem_cache = None
 
-            return (order, name, modulus, impl, p, n, proof, prefix, repr, elem_cache, check_prime, check_irreducible), {}
+            return (order, name, modulus, implementation, p, n, proof, prefix, repr, elem_cache, check_prime, check_irreducible), {}
 
+    @rename_keyword(deprecation=30507, impl='implementation')
     def create_object(self, version, key, **kwds):
         """
         EXAMPLES::
@@ -684,37 +687,37 @@ def create_object(self, version, key, **kwds):
 
         We try to create finite fields with various implementations::
 
-            sage: k = GF(2, impl='modn')
-            sage: k = GF(2, impl='givaro')                                              # needs sage.libs.linbox
-            sage: k = GF(2, impl='ntl')                                                 # needs sage.libs.ntl
-            sage: k = GF(2, impl='pari')
+            sage: k = GF(2, implementation='modn')
+            sage: k = GF(2, implementation='givaro')                                              # needs sage.libs.linbox
+            sage: k = GF(2, implementation='ntl')                                                 # needs sage.libs.ntl
+            sage: k = GF(2, implementation='pari')
             Traceback (most recent call last):
             ...
             ValueError: the degree must be at least 2
-            sage: k = GF(2, impl='supercalifragilisticexpialidocious')
+            sage: k = GF(2, implementation='supercalifragilisticexpialidocious')
             Traceback (most recent call last):
             ...
             ValueError: no such finite field implementation: 'supercalifragilisticexpialidocious'
-            sage: k.<a> = GF(2^15, impl='modn')
+            sage: k.<a> = GF(2^15, implementation='modn')
             Traceback (most recent call last):
             ...
             ValueError: the 'modn' implementation requires a prime order
-            sage: k.<a> = GF(2^15, impl='givaro')                                       # needs sage.libs.linbox
-            sage: k.<a> = GF(2^15, impl='ntl')                                          # needs sage.libs.ntl
-            sage: k.<a> = GF(2^15, impl='pari')
-            sage: k.<a> = GF(3^60, impl='modn')
+            sage: k.<a> = GF(2^15, implementation='givaro')                                       # needs sage.libs.linbox
+            sage: k.<a> = GF(2^15, implementation='ntl')                                          # needs sage.libs.ntl
+            sage: k.<a> = GF(2^15, implementation='pari')
+            sage: k.<a> = GF(3^60, implementation='modn')
             Traceback (most recent call last):
             ...
             ValueError: the 'modn' implementation requires a prime order
-            sage: k.<a> = GF(3^60, impl='givaro')                                       # needs sage.libs.linbox
+            sage: k.<a> = GF(3^60, implementation='givaro')                                       # needs sage.libs.linbox
             Traceback (most recent call last):
             ...
             ValueError: q must be < 2^16
-            sage: k.<a> = GF(3^60, impl='ntl')                                          # needs sage.libs.ntl
+            sage: k.<a> = GF(3^60, implementation='ntl')                                          # needs sage.libs.ntl
             Traceback (most recent call last):
             ...
             ValueError: q must be a 2-power
-            sage: k.<a> = GF(3^60, impl='pari')
+            sage: k.<a> = GF(3^60, implementation='pari')
         """
         # IMPORTANT!  If you add a new class to the list of classes
         # that get cached by this factor object, then you *must* add
@@ -730,7 +733,7 @@ def create_object(self, version, key, **kwds):
 
         if len(key) == 5:
             # for backward compatibility of pickles (see trac 10975).
-            order, name, modulus, impl, _ = key
+            order, name, modulus, implementation, _ = key
             p, n = Integer(order).factor()[0]
             proof = True
             prefix = kwds.get('prefix', None)
@@ -741,7 +744,7 @@ def create_object(self, version, key, **kwds):
             check_prime = check_irreducible = False
         elif len(key) == 8:
             # For backward compatibility of pickles (see trac #21433)
-            order, name, modulus, impl, _, p, n, proof = key
+            order, name, modulus, implementation, _, p, n, proof = key
             prefix = kwds.get('prefix', None)
             # We can set the defaults here to be those for givaro
             #   as they are otherwise ignored
@@ -749,10 +752,10 @@ def create_object(self, version, key, **kwds):
             elem_cache = kwds.get('elem_cache', (order < 500))
             check_prime = check_irreducible = False
         elif len(key) == 10:
-            order, name, modulus, impl, p, n, proof, prefix, repr, elem_cache = key
+            order, name, modulus, implementation, p, n, proof, prefix, repr, elem_cache = key
             check_prime = check_irreducible = False
         else:
-            order, name, modulus, impl, p, n, proof, prefix, repr, elem_cache, check_prime, check_irreducible = key
+            order, name, modulus, implementation, p, n, proof, prefix, repr, elem_cache, check_prime, check_irreducible = key
 
         from sage.structure.proof.all import WithProof
         with WithProof('arithmetic', proof):
@@ -761,7 +764,7 @@ def create_object(self, version, key, **kwds):
             if check_irreducible and not modulus.is_irreducible():
                 raise ValueError("finite field modulus must be irreducible but it is not")
 
-        if impl == 'modn':
+        if implementation == 'modn':
             if n != 1:
                 raise ValueError("the 'modn' implementation requires a prime order")
             from .finite_field_prime_modn import FiniteField_prime_modn
@@ -776,15 +779,15 @@ def create_object(self, version, key, **kwds):
             # Otherwise, we would have to complicate all of their
             # constructors with check options.
             with WithProof('arithmetic', proof):
-                if impl == 'givaro':
+                if implementation == 'givaro':
                     K = FiniteField_givaro(order, name, modulus, repr, elem_cache)
-                elif impl == 'ntl':
+                elif implementation == 'ntl':
                     K = FiniteField_ntl_gf2e(order, name, modulus)
-                elif impl == 'pari_ffelt' or impl == 'pari':
+                elif implementation == 'pari_ffelt' or implementation == 'pari':
                     from .finite_field_pari_ffelt import FiniteField_pari_ffelt
                     K = FiniteField_pari_ffelt(p, modulus, name)
                 else:
-                    raise ValueError("no such finite field implementation: %r" % impl)
+                    raise ValueError("no such finite field implementation: %r" % implementation)
 
             # Temporary; see create_key_and_extra_args() above.
             if prefix is not None:
diff --git a/src/sage/rings/finite_rings/finite_field_givaro.py b/src/sage/rings/finite_rings/finite_field_givaro.py
index 9f6abdb40b4..2662ceed7ca 100644
--- a/src/sage/rings/finite_rings/finite_field_givaro.py
+++ b/src/sage/rings/finite_rings/finite_field_givaro.py
@@ -89,19 +89,19 @@ class FiniteField_givaro(FiniteField):
 
     Three different representations are possible::
 
-        sage: FiniteField(9, 'a', impl='givaro', repr='poly').gen()
+        sage: FiniteField(9, 'a', implementation='givaro', repr='poly').gen()
         a
-        sage: FiniteField(9, 'a', impl='givaro', repr='int').gen()
+        sage: FiniteField(9, 'a', implementation='givaro', repr='int').gen()
         3
-        sage: FiniteField(9, 'a', impl='givaro', repr='log').gen()
+        sage: FiniteField(9, 'a', implementation='givaro', repr='log').gen()
         1
 
     For prime fields, the default modulus is the polynomial `x - 1`,
     but you can ask for a different modulus::
 
-        sage: GF(1009, impl='givaro').modulus()
+        sage: GF(1009, implementation='givaro').modulus()
         x + 1008
-        sage: GF(1009, impl='givaro', modulus='conway').modulus()
+        sage: GF(1009, implementation='givaro', modulus='conway').modulus()
         x + 998
     """
     def __init__(self, q, name="a", modulus=None, repr="poly", cache=False):
@@ -286,7 +286,7 @@ def _element_constructor_(self, e):
         the polynomial at the field's generator::
 
             sage: R.<x> = QQ[]
-            sage: k.<a> = FiniteField(5^2, 'a', impl='givaro')
+            sage: k.<a> = FiniteField(5^2, 'a', implementation='givaro')
             sage: k(R(2/3))
             4
             sage: k(x^2)
@@ -299,7 +299,7 @@ def _element_constructor_(self, e):
             sage: k(x^25)
             a
 
-            sage: Q.<q> = FiniteField(5^3, 'q', impl='givaro')
+            sage: Q.<q> = FiniteField(5^3, 'q', implementation='givaro')
             sage: L = GF(5)
             sage: LL.<xx> = L[]
             sage: Q(xx^2 + 2*xx + 4)
@@ -334,22 +334,22 @@ def _element_constructor_(self, e):
 
         We can coerce from PARI finite field implementations::
 
-            sage: K.<a> = GF(3^10, impl="givaro")
+            sage: K.<a> = GF(3^10, implementation="givaro")
             sage: a^20
             2*a^9 + 2*a^8 + a^7 + 2*a^5 + 2*a^4 + 2*a^3 + 1
-            sage: M.<c> = GF(3^10, impl="pari_ffelt")
+            sage: M.<c> = GF(3^10, implementation="pari_ffelt")
             sage: K(c^20)
             2*a^9 + 2*a^8 + a^7 + 2*a^5 + 2*a^4 + 2*a^3 + 1
 
         GAP elements need to be finite field elements::
 
             sage: x = gap('Z(13)')
-            sage: F = FiniteField(13, impl='givaro')
+            sage: F = FiniteField(13, implementation='givaro')
             sage: F(x)
             2
             sage: F(gap('0*Z(13)'))
             0
-            sage: F = FiniteField(13^2, 'a', impl='givaro')
+            sage: F = FiniteField(13^2, 'a', implementation='givaro')
             sage: x = gap('Z(13)')
             sage: F(x)
             2
@@ -363,8 +363,8 @@ def _element_constructor_(self, e):
             sage: k(48771/1225)
             28
 
-            sage: F9 = FiniteField(9, impl='givaro', prefix='a')
-            sage: F81 = FiniteField(81, impl='givaro', prefix='a')
+            sage: F9 = FiniteField(9, implementation='givaro', prefix='a')
+            sage: F81 = FiniteField(81, implementation='givaro', prefix='a')
             sage: F81(F9.gen())
             2*a4^3 + 2*a4^2 + 1
         """
@@ -399,7 +399,7 @@ def gen(self, n=0):
             Traceback (most recent call last):
             ...
             IndexError: only one generator
-            sage: F = FiniteField(31, impl='givaro')
+            sage: F = FiniteField(31, implementation='givaro')
             sage: F.gen()
             1
         """
diff --git a/src/sage/rings/finite_rings/finite_field_ntl_gf2e.py b/src/sage/rings/finite_rings/finite_field_ntl_gf2e.py
index 654f7a2b54b..785158c7c33 100644
--- a/src/sage/rings/finite_rings/finite_field_ntl_gf2e.py
+++ b/src/sage/rings/finite_rings/finite_field_ntl_gf2e.py
@@ -107,7 +107,7 @@ def __init__(self, q, names="a", modulus=None, repr="poly"):
             sage: k2.<a> = GF(2^17)
             sage: k1 == k2
             False
-            sage: k3.<a> = GF(2^16, impl="pari_ffelt")
+            sage: k3.<a> = GF(2^16, implementation="pari_ffelt")
             sage: k1 == k3
             False
 
@@ -242,9 +242,9 @@ def gen(self, n=0):
 
         TESTS::
 
-            sage: GF(2, impl='ntl').gen()
+            sage: GF(2, implementation='ntl').gen()
             1
-            sage: GF(2, impl='ntl', modulus=polygen(GF(2)) ).gen()
+            sage: GF(2, implementation='ntl', modulus=polygen(GF(2)) ).gen()
             0
             sage: GF(2^19, 'a').gen(1)
             Traceback (most recent call last):
diff --git a/src/sage/rings/finite_rings/finite_field_pari_ffelt.py b/src/sage/rings/finite_rings/finite_field_pari_ffelt.py
index c60a7a563a7..96d5f90c70b 100644
--- a/src/sage/rings/finite_rings/finite_field_pari_ffelt.py
+++ b/src/sage/rings/finite_rings/finite_field_pari_ffelt.py
@@ -48,13 +48,13 @@ class FiniteField_pari_ffelt(FiniteField):
         requires specifying a characteristic and a modulus.  To
         construct a finite field by specifying a cardinality and an
         algorithm for finding an irreducible polynomial, use the
-        ``FiniteField`` constructor with ``impl='pari_ffelt'``.
+        ``FiniteField`` constructor with ``implementation='pari_ffelt'``.
 
     EXAMPLES:
 
     Some computations with a finite field of order 9::
 
-        sage: k = FiniteField(9, 'a', impl='pari_ffelt')
+        sage: k = FiniteField(9, 'a', implementation='pari_ffelt')
         sage: k
         Finite Field in a of size 3^2
         sage: k.is_field()
@@ -74,7 +74,7 @@ class FiniteField_pari_ffelt(FiniteField):
 
     Next we compute with a finite field of order 16::
 
-        sage: k16 = FiniteField(16, 'b', impl='pari_ffelt')
+        sage: k16 = FiniteField(16, 'b', implementation='pari_ffelt')
         sage: z = k16.gen()
         sage: z
         b
@@ -89,11 +89,11 @@ class FiniteField_pari_ffelt(FiniteField):
 
     Illustration of dumping and loading::
 
-        sage: K = FiniteField(7^10, 'b', impl='pari_ffelt')
+        sage: K = FiniteField(7^10, 'b', implementation='pari_ffelt')
         sage: loads(K.dumps()) == K
         True
 
-        sage: K = FiniteField(10007^10, 'a', impl='pari_ffelt')
+        sage: K = FiniteField(10007^10, 'a', implementation='pari_ffelt')
         sage: loads(K.dumps()) == K
         True
     """
@@ -135,7 +135,7 @@ def __reduce__(self):
 
         EXAMPLES::
 
-            sage: k.<b> = FiniteField(5^20, impl='pari_ffelt')
+            sage: k.<b> = FiniteField(5^20, implementation='pari_ffelt')
             sage: type(k)
             <class 'sage.rings.finite_rings.finite_field_pari_ffelt.FiniteField_pari_ffelt_with_category'>
             sage: k is loads(dumps(k))
@@ -167,9 +167,9 @@ def gen(self, n=0):
         EXAMPLES::
 
             sage: R.<x> = PolynomialRing(GF(2))
-            sage: FiniteField(2^4, 'b', impl='pari_ffelt').gen()
+            sage: FiniteField(2^4, 'b', implementation='pari_ffelt').gen()
             b
-            sage: k = FiniteField(3^4, 'alpha', impl='pari_ffelt')
+            sage: k = FiniteField(3^4, 'alpha', implementation='pari_ffelt')
             sage: a = k.gen()
             sage: a
             alpha
@@ -186,7 +186,7 @@ def characteristic(self):
 
         EXAMPLES::
 
-            sage: F = FiniteField(3^4, 'a', impl='pari_ffelt')
+            sage: F = FiniteField(3^4, 'a', implementation='pari_ffelt')
             sage: F.characteristic()
             3
         """
@@ -199,7 +199,7 @@ def degree(self):
 
         EXAMPLES::
 
-            sage: F = FiniteField(3^20, 'a', impl='pari_ffelt')
+            sage: F = FiniteField(3^20, 'a', implementation='pari_ffelt')
             sage: F.degree()
             20
         """
@@ -212,7 +212,7 @@ def _pari_frobenius(self, k=1):
 
         TESTS::
 
-            sage: F = FiniteField(37^10, 'a', impl='pari_ffelt')
+            sage: F = FiniteField(37^10, 'a', implementation='pari_ffelt')
             sage: x = F.random_element()                                                # needs sage.modules
             sage: all(x**(37**k) == F(F._pari_frobenius(k).ffmap(x))                    # needs sage.modules
             ....:     for k in range(1, 30) if k % 10 != 0)
diff --git a/src/sage/rings/finite_rings/residue_field.pyx b/src/sage/rings/finite_rings/residue_field.pyx
index 83d78abb2aa..338b7c136f8 100644
--- a/src/sage/rings/finite_rings/residue_field.pyx
+++ b/src/sage/rings/finite_rings/residue_field.pyx
@@ -309,7 +309,7 @@ class ResidueFieldFactory(UniqueFactory):
         sage: K.residue_field(K.ideal(3))                                               # needs sage.rings.number_field
         Residue field of Fractional ideal (3)
     """
-    def create_key_and_extra_args(self, p, names = None, check=True, impl=None, **kwds):
+    def create_key_and_extra_args(self, p, names = None, check=True, implementation=None, **kwds):
         """
         Return a tuple containing the key (uniquely defining data)
         and any extra arguments.
@@ -354,7 +354,7 @@ class ResidueFieldFactory(UniqueFactory):
                 names = None
         if names is None and p.ring() is not ZZ:
             names = '%sbar' % p.ring().fraction_field().variable_name()
-        key = (p, names, impl)
+        key = (p, names, implementation)
         return key, kwds
 
     def create_object(self, version, key, **kwds):
@@ -370,7 +370,7 @@ class ResidueFieldFactory(UniqueFactory):
             sage: ResidueField(P) is ResidueField(P)  # indirect doctest                # needs sage.rings.number_field
             True
         """
-        p, names, impl = key
+        p, names, implementation = key
         pring = p.ring()
 
         if pring is ZZ:
@@ -380,31 +380,31 @@ class ResidueFieldFactory(UniqueFactory):
             Kbase = pring.base_ring()
             f = p.gen()
             characteristic = Kbase.order()
-            if f.degree() == 1 and Kbase.is_prime_field() and (impl is None or impl == 'modn'):
+            if f.degree() == 1 and Kbase.is_prime_field() and (implementation is None or implementation == 'modn'):
                 return ResidueFiniteField_prime_modn(p, None, Kbase.order(), None, None, None)
             else:
                 q = characteristic**(f.degree())
-                if q < zech_log_bound and (impl is None or impl == 'givaro'):
+                if q < zech_log_bound and (implementation is None or implementation == 'givaro'):
                     try:
                         from sage.rings.finite_rings.residue_field_givaro import ResidueFiniteField_givaro
                     except ImportError:
-                        if impl is not None:
+                        if implementation is not None:
                             raise
                     else:
                         return ResidueFiniteField_givaro(p, q, names, f, None, None, None)
-                if q % 2 == 0 and (impl is None or impl == 'ntl'):
+                if q % 2 == 0 and (implementation is None or implementation == 'ntl'):
                     try:
                         from sage.rings.finite_rings.residue_field_ntl_gf2e import ResidueFiniteField_ntl_gf2e
                     except ImportError:
-                        if impl is not None:
+                        if implementation is not None:
                             raise
                     else:
                         return ResidueFiniteField_ntl_gf2e(q, names, f, "poly", p, None, None, None)
-                if impl is None or impl == 'pari':
+                if implementation is None or implementation == 'pari':
                     try:
                         from sage.rings.finite_rings.residue_field_pari_ffelt import ResidueFiniteField_pari_ffelt
                     except ImportError:
-                        if impl is not None:
+                        if implementation is not None:
                             raise
                     else:
                         return ResidueFiniteField_pari_ffelt(p, characteristic, names, f, None, None, None)
@@ -460,27 +460,27 @@ class ResidueFieldFactory(UniqueFactory):
             return ResidueFiniteField_prime_modn(p, names, p.smallest_integer(), to_vs, to_order, PB)
         else:
             q = characteristic**(f.degree())
-            if q < zech_log_bound and (impl is None or impl == 'givaro'):
+            if q < zech_log_bound and (implementation is None or implementation == 'givaro'):
                 try:
                     from sage.rings.finite_rings.residue_field_givaro import ResidueFiniteField_givaro
                 except ImportError:
-                    if impl is not None:
+                    if implementation is not None:
                         raise
                 else:
                     return ResidueFiniteField_givaro(p, q, names, f, to_vs, to_order, PB)
-            elif q % 2 == 0 and (impl is None or impl == 'ntl'):
+            elif q % 2 == 0 and (implementation is None or implementation == 'ntl'):
                 try:
                     from sage.rings.finite_rings.residue_field_ntl_gf2e import ResidueFiniteField_ntl_gf2e
                 except ImportError:
-                    if impl is not None:
+                    if implementation is not None:
                         raise
                 else:
                     return ResidueFiniteField_ntl_gf2e(q, names, f, "poly", p, to_vs, to_order, PB)
-            if impl is None or impl == 'pari':
+            if implementation is None or implementation == 'pari':
                 try:
                     from sage.rings.finite_rings.residue_field_pari_ffelt import ResidueFiniteField_pari_ffelt
                 except ImportError:
-                    if impl is not None:
+                    if implementation is not None:
                         raise
                 else:
                     return ResidueFiniteField_pari_ffelt(p, characteristic, names, f, to_vs, to_order, PB)