passagemath-modules 10.5.32__cp310-cp310-macosx_14_0_arm64.whl → 10.6.20__cp310-cp310-macosx_14_0_arm64.whl

sage/modules/free_module_pseudomorphism.py

@@ -0,0 +1,578 @@
+# sage_setup: distribution = sagemath-modules
+# sage.doctest: needs sage.rings.finite_rings
+"""
+Pseudomorphisms of free modules
+
+AUTHORS:
+
+- Xavier Caruso, Yossef Musleh (2024-09): initial version
+"""
+# ****************************************************************************
+#  Copyright (C) 2024 Xavier Caruso <xavier.caruso@normalesup.org>
+#                     Yossef Musleh <specialholonomy@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#    General Public License for more details.
+#
+#  The full text of the GPL is available at:
+#
+#                  http://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.categories.morphism import Morphism
+from sage.structure.richcmp import richcmp
+from sage.modules.free_module_morphism import FreeModuleMorphism
+
+
+class FreeModulePseudoMorphism(Morphism):
+    r"""
+    Let `M, M'` be modules over a ring `R`, `\theta: R \to R` a
+    ring homomorphism, and `\delta: R \to R` a `\theta`-derivation,
+    which is a map such that:
+
+    .. MATH::
+
+        \delta(xy) = \theta(x)\delta(y) + \delta(x)y.
+
+    A pseudomorphism `f : M \to M` is an additive map such that
+
+    .. MATH::
+
+        f(\lambda x) = \theta(\lambda)f(x) + \delta(\lambda) x
+
+    The map `\theta` (resp. `\delta`) is referred to as the
+    twisting endomorphism (resp. the twisting derivation) of `f`.
+
+    .. NOTE::
+
+        The implementation currently requires that `M` and `M'`
+        are free modules.
+
+    We represent pseudomorphisms by matrices with coefficient in the
+    base ring `R`. The matrix `\mathcal M_f` representing `f` is such
+    that its lines (resp. columns if ``side`` is ``"right"``) are the
+    coordinates of the images of the distinguished basis of the domain
+    (see also method :meth:`matrix`).
+    More concretely, let `n` (resp. `n'`) be the dimension of `M`
+    (resp. `M'`), let `(e_1, \dots, e_n)` be a basis of `M`.
+    For any `x = \sum_{i=1}^n x_i e_i \in M`, we have
+
+    .. MATH::
+
+        f(x) = \begin{pmatrix}
+                 \theta(x_1) & \cdots & \theta(x_n)
+               \end{pmatrix}
+               \mathcal M_f
+               +
+               \begin{pmatrix}
+                 \delta(x_1) & \cdots & \theta(x_n)
+               \end{pmatrix}
+               .
+
+    When ``side`` is ``"right"``, the formula is
+
+    .. MATH::
+
+        f(x) = \mathcal M_f
+               \begin{pmatrix}
+                 \theta(x_1) \\ \vdots \\ \theta(x_n)
+               \end{pmatrix}
+               +
+               \begin{pmatrix}
+                 \delta(x_1) \\ \vdots \\ \theta(x_n)
+               \end{pmatrix}
+               .
+
+    This class is not supposed to be instantiated directly; the user
+    should use instead the method
+    :meth:`sage.rings.module.free_module.FreeModule_generic.pseudohom`
+    to create a pseudomorphism.
+
+    TESTS::
+
+        sage: P.<x> = ZZ[]
+        sage: d = P.derivation()
+        sage: M = P^2
+        sage: f = M.pseudohom([[1, 2*x], [x, 1]], d); f
+        Free module pseudomorphism (twisted by d/dx) defined by the matrix
+        [  1 2*x]
+        [  x   1]
+        Domain: Ambient free module of rank 2 over the integral domain Univariate Polynomial Ring in x over Integer Ring
+        Codomain: Ambient free module of rank 2 over the integral domain Univariate Polynomial Ring in x over Integer Ring
+        sage: e = M((2*x^2 + 3*x + 1, x^3 + 7*x + 4))
+        sage: f(e)
+        (x^4 + 9*x^2 + 11*x + 4, 5*x^3 + 9*x^2 + 9*x + 11)
+        sage: f = M.pseudohom([[1, 2], [1, 1]], d)
+        sage: f(e)
+        (x^3 + 2*x^2 + 14*x + 8, x^3 + 7*x^2 + 13*x + 13)
+
+    ::
+
+        sage: Fq.<z> = GF(7^3)
+        sage: Frob = Fq.frobenius_endomorphism()
+        sage: M = Fq^3
+        sage: N = Fq^2
+        sage: phi = M.pseudohom([[2, 3, 1], [1, 4, 6]], Frob, codomain=N, side="right")
+        sage: phi
+        Free module pseudomorphism (twisted by z |--> z^7) defined as left-multiplication by the matrix
+        [2 3 1]
+        [1 4 6]
+        Domain: Vector space of dimension 3 over Finite Field in z of size 7^3
+        Codomain: Vector space of dimension 2 over Finite Field in z of size 7^3
+        sage: v = (4*z^2 + 4*z + 3, 2, z + 5)
+        sage: phi(v)
+        (2*z + 1, 6*z^2 + 4*z + 5)
+    """
+    def __init__(self, parent, f, side):
+        """
+        Constructs a pseudomorphism of free modules.
+
+        INPUT:
+
+        - ``parent`` -- the parent space of pseudomorphisms
+
+        - ``f`` -- a pseudomorphism or a matrix defining this
+          pseudomorphism
+
+        - ``side`` -- side of the vectors acted on by the matrix
+
+        TESTS::
+
+            sage: F.<z> = GF(5^3)
+            sage: Frob = F.frobenius_endomorphism()
+            sage: M = F^2
+            sage: H = M.pseudoHom(Frob)
+            sage: H
+            Set of Pseudoendomorphisms (twisted by z |--> z^5) of Vector space of dimension 2 over Finite Field in z of size 5^3
+
+        The attribute ``f`` can be a matrix::
+
+            sage: mat = matrix(F, 2, [1, z, z^2, z^3])
+            sage: f = H(mat)
+            sage: f
+            Free module pseudomorphism (twisted by z |--> z^5) defined by the matrix
+            [      1       z]
+            [    z^2 2*z + 2]
+            Domain: Vector space of dimension 2 over Finite Field in z of size 5^3
+            Codomain: Vector space of dimension 2 over Finite Field in z of size 5^3
+
+            sage: type(f)
+            <class 'sage.modules.free_module_pseudohomspace.FreeModulePseudoHomspace_with_category.element_class'>
+
+        or a pseudomorphism with the same parent::
+
+            sage: H(f)
+            Free module pseudomorphism (twisted by z |--> z^5) defined by the matrix
+            [      1       z]
+            [    z^2 2*z + 2]
+            Domain: Vector space of dimension 2 over Finite Field in z of size 5^3
+            Codomain: Vector space of dimension 2 over Finite Field in z of size 5^3
+
+        When the twisting morphism and the twisting derivation are both trivial,
+        pseudomorphisms are just linear applications and coercion between those
+        works::
+
+            sage: id = End(F).identity()
+            sage: g = M.hom(mat)
+            sage: g2 = M.pseudoHom(id)(g)
+            sage: g2
+            Free module pseudomorphism (untwisted) defined by the matrix
+            [      1       z]
+            [    z^2 2*z + 2]
+            Domain: Vector space of dimension 2 over Finite Field in z of size 5^3
+            Codomain: Vector space of dimension 2 over Finite Field in z of size 5^3
+
+        An example with ``side=right``::
+
+            sage: h = M.pseudohom(mat, Frob, side="right")
+            sage: h
+            Free module pseudomorphism (twisted by z |--> z^5) defined as left-multiplication by the matrix
+            [      1       z]
+            [    z^2 2*z + 2]
+            Domain: Vector space of dimension 2 over Finite Field in z of size 5^3
+            Codomain: Vector space of dimension 2 over Finite Field in z of size 5^3
+
+        ::
+
+            sage: M.pseudohom(mat, Frob, side="middle")
+            Traceback (most recent call last):
+            ...
+            ValueError: the side must be either 'left' or 'right'
+
+        ::
+
+            sage: TestSuite(f).run()
+            sage: TestSuite(g2).run()
+            sage: TestSuite(h).run()
+        """
+        Morphism.__init__(self, parent)
+        dom = parent.domain()
+        codom = parent.codomain()
+        if side != "left" and side != "right":
+            raise ValueError("the side must be either 'left' or 'right'")
+        matrix_space = parent.matrix_space()
+        if ((isinstance(f, FreeModulePseudoMorphism) and f.parent() is parent)
+         or (isinstance(f, FreeModuleMorphism)
+          and f.domain() is dom and f.codomain() is codom
+          and parent._morphism is None and parent._derivation is None)):
+            if f.side() == 'right':
+                self._matrix = f.matrix().transpose()
+            else:
+                self._matrix = f.matrix()
+        else:
+            if side == "right":
+                self._matrix = matrix_space.transposed(f).transpose()
+            else:
+                self._matrix = matrix_space(f)
+        self._morphism = parent._morphism
+        self._derivation = parent._derivation
+        self._side = side
+
+    def _call_(self, x):
+        r"""
+        Return the result of applying this pseudomorphism to ``x``.
+
+        TESTS::
+
+            sage: Fq.<z> = GF(7^3)
+            sage: M = Fq^3
+            sage: Frob = Fq.frobenius_endomorphism()
+            sage: f = M.pseudohom([[1, z, 3], [0, 1, 1], [2, 1, 1]], Frob)
+            sage: e = M((3*z^2 + 5*z + 2, 6*z^2 + 2*z + 2, z + 4))
+            sage: f(e)
+            (3*z^2 + 4*z + 4, 6*z^2 + 5*z + 6, 6*z^2 + 5*z + 3)
+
+        ::
+
+            sage: g = M.pseudohom([[1, z, 3], [0, 1, 1], [2, 1, 1]], Frob, side="right")
+            sage: g(e)
+            (z^2 + 6*z + 2, z^2 + 2*z + 1, 2*z^2 + 4*z)
+        """
+        D = self.domain()
+        C = self.codomain()
+        if D.is_ambient():
+            x = x.element()
+        else:
+            x = D.coordinate_vector(x)
+        if self._morphism is None:
+            x_twist = x
+        else:
+            x_twist = D(list(map(self._morphism, x)))
+        v = x_twist * self._matrix
+        if C.is_ambient():
+            v = C(v.list())
+        else:
+            v = C.linear_combination_of_basis(v)
+        if self._derivation is not None:
+            v += D(list(map(self._derivation, x)))
+        return v
+
+    def _repr_(self):
+        r"""
+        Return the string representation of a pseudomorphism.
+
+        TESTS::
+
+            sage: Fq.<z> = GF(7^3)
+            sage: M = Fq^3
+            sage: Frob = Fq.frobenius_endomorphism()
+
+            sage: f = M.pseudohom([[1,1,1], [2,2,2], [3,3,3]], Frob)
+            sage: f  # indirect doctest
+            Free module pseudomorphism (twisted by z |--> z^7) defined by the matrix
+            [1 1 1]
+            [2 2 2]
+            [3 3 3]
+            Domain: Vector space of dimension 3 over Finite Field in z of size 7^3
+            Codomain: Vector space of dimension 3 over Finite Field in z of size 7^3
+
+            sage: g = M.pseudohom([[1,1,1], [2,2,2], [3,3,3]], Frob, side="right")
+            sage: g  # indirect doctest
+            Free module pseudomorphism (twisted by z |--> z^7) defined as left-multiplication by the matrix
+            [1 1 1]
+            [2 2 2]
+            [3 3 3]
+            Domain: Vector space of dimension 3 over Finite Field in z of size 7^3
+            Codomain: Vector space of dimension 3 over Finite Field in z of size 7^3
+        """
+        twist = self.parent()._ore._repr_twist()
+        s = "Free module pseudomorphism (%s) defined " % twist
+        if self._side == "right":
+            s += "as left-multiplication "
+        s += "by the matrix\n%s\n" % self.matrix()
+        s += "Domain: %s\n" % self.domain()
+        s += "Codomain: %s" % self.codomain()
+        return s
+
+    def matrix(self):
+        r"""
+        Return the underlying matrix of this pseudomorphism.
+
+        It is defined as the matrix `M` whose lines (resp. columns if
+        ``side`` is ``"right"``) are the coordinates of the images of
+        the distinguished basis of the domain.
+
+        EXAMPLES::
+
+            sage: Fq.<z> = GF(7^3)
+            sage: Frob = Fq.frobenius_endomorphism()
+            sage: M = Fq^3
+            sage: f = M.pseudohom([[1, z, 3], [0, 1, z^2], [z+1, 1, 1]], Frob)
+            sage: f.matrix()
+            [    1     z     3]
+            [    0     1   z^2]
+            [z + 1     1     1]
+
+        ::
+
+            sage: e1, e2, e3 = M.basis()
+            sage: f(e1)
+            (1, z, 3)
+            sage: f(e2)
+            (0, 1, z^2)
+            sage: f(e3)
+            (z + 1, 1, 1)
+
+        TESTS::
+
+            sage: v = M.random_element()
+            sage: f(v) == vector([Frob(c) for c in v]) * f.matrix()
+            True
+        """
+        if self._side == "left":
+            return self._matrix.__copy__()
+        else:
+            return self._matrix.transpose()
+
+    def twisting_derivation(self):
+        r"""
+        Return the twisting derivation of the pseudomorphism
+        (or ``None`` if the twisting derivation is zero).
+
+        EXAMPLES::
+
+            sage: P.<x> = ZZ[]
+            sage: d = P.derivation()
+            sage: M = P^2
+            sage: f = M.pseudohom([[1, 2*x], [x, 1]], d)
+            sage: f.twisting_derivation()
+            d/dx
+
+        ::
+
+            sage: Fq.<z> = GF(7^3)
+            sage: Frob = Fq.frobenius_endomorphism()
+            sage: V = Fq^2
+            sage: f = V.pseudohom([[1, z], [0, z^2]], Frob)
+            sage: f.twisting_derivation()
+        """
+        return self._derivation
+
+    def twisting_morphism(self):
+        r"""
+        Return the twisting morphism of the pseudomorphism
+        (or ``None`` if the twisting morphism is the identity).
+
+        EXAMPLES::
+
+            sage: Fq.<z> = GF(7^3)
+            sage: Frob = Fq.frobenius_endomorphism()
+            sage: V = Fq^2
+            sage: f = V.pseudohom([[1, z], [0, z^2]], Frob)
+            sage: f.twisting_morphism()
+            Frobenius endomorphism z |--> z^7 on Finite Field in z of size 7^3
+
+        ::
+
+            sage: P.<x> = ZZ[]
+            sage: d = P.derivation()
+            sage: M = P^2
+            sage: f = M.pseudohom([[1, 2*x], [x, 1]], d)
+            sage: f.twisting_morphism()
+        """
+        return self._morphism
+
+    def side(self):
+        """
+        Return the side of vectors acted on, relative to the matrix.
+
+        EXAMPLES::
+
+            sage: Fq.<z> = GF(7^3)
+            sage: Frob = Fq.frobenius_endomorphism()
+            sage: V = Fq^2
+
+            sage: m = matrix(2, [1, z, z^2, z^3])
+            sage: h1 = V.pseudohom(m, Frob)
+            sage: h1.side()
+            'left'
+            sage: h1([1, 0])
+            (1, z)
+
+            sage: h2 = V.pseudohom(m, Frob, side="right")
+            sage: h2.side()
+            'right'
+            sage: h2([1, 0])
+            (1, z^2)
+        """
+        return self._side
+
+    def side_switch(self):
+        """
+        Return the same morphism, acting on vectors on the opposite side.
+
+        EXAMPLES::
+
+            sage: Fq.<z> = GF(7^3)
+            sage: Frob = Fq.frobenius_endomorphism()
+            sage: V = Fq^2
+
+            sage: m = matrix(2, [1, z, z^2, z^3])
+            sage: h1 = V.pseudohom(m, Frob)
+            sage: h1
+            Free module pseudomorphism (twisted by z |--> z^7) defined by the matrix
+            [      1       z]
+            [    z^2 z^2 + 3]
+            Domain: Vector space of dimension 2 over Finite Field in z of size 7^3
+            Codomain: Vector space of dimension 2 over Finite Field in z of size 7^3
+
+            sage: h2 = h1.side_switch()
+            sage: h2
+            Free module pseudomorphism (twisted by z |--> z^7) defined as left-multiplication by the matrix
+            [      1     z^2]
+            [      z z^2 + 3]
+            Domain: Vector space of dimension 2 over Finite Field in z of size 7^3
+            Codomain: Vector space of dimension 2 over Finite Field in z of size 7^3
+
+        We check that ``h1`` and ``h2`` are the same::
+
+            sage: v = V.random_element()
+            sage: h1(v) == h2(v)
+            True
+        """
+        if self._side == "left":
+            side = "right"
+            mat = self._matrix.transpose()
+        else:
+            side = "left"
+            mat = self._matrix
+        return self.parent()(mat, side)
+
+    def __nonzero__(self):
+        return not (self._derivation is None and self._matrix)
+
+    def _richcmp_(self, other, op):
+        r"""
+        Compare this morphism with ``other``.
+
+        TESTS::
+
+            sage: Fq.<z> = GF(7^3)
+            sage: Frob = Fq.frobenius_endomorphism()
+            sage: V = Fq^2
+            sage: m = matrix(2, 2, [z, z^3, z^5, z^7])
+
+            sage: f = V.pseudohom(m, Frob)
+            sage: g = V.pseudohom(m.transpose(), Frob, side="right")
+            sage: f == g
+            True
+
+            sage: g = V.pseudohom(m.transpose(), Frob)
+            sage: f == g
+            False
+            sage: f < g
+            True
+            sage: f > g
+            False
+
+        ::
+
+            sage: g = V.pseudohom(m, Frob^2)
+            sage: f == g
+            False
+
+            sage: g = V.pseudohom(m, Frob^3)
+            sage: h = V.hom(m)
+            sage: g == h
+            True
+
+        ::
+
+            sage: f < V
+            Traceback (most recent call last):
+            ...
+            TypeError: unsupported operand parent(s) for <: 'Set of Pseudoendomorphisms (twisted by z |--> z^7) of Vector space of dimension 2 over Finite Field in z of size 7^3' and '<class 'sage.modules.free_module.FreeModule_ambient_field_with_category'>'
+        """
+        return richcmp(self._matrix, other._matrix, op)
+
+    def ore_module(self, names=None):
+        r"""
+        Return the Ore module over which the Ore variable acts
+        through this pseudomorphism.
+
+        INPUT:
+
+        - ``names`` -- a string, a list of strings or ``None``,
+          the names of the vector of the canonical basis of the
+          Ore module; if ``None``, elements are represented as
+          vectors in `K^d` (where `K` is the base ring)
+
+        EXAMPLES::
+
+            sage: Fq.<z> = GF(7^3)
+            sage: Frob = Fq.frobenius_endomorphism()
+            sage: V = Fq^2
+            sage: mat = matrix(2, [1, z, z^2, z^3])
+            sage: f = V.pseudohom(mat, Frob)
+
+            sage: M = f.ore_module()
+            sage: M
+            Ore module of rank 2 over Finite Field in z of size 7^3 twisted by z |--> z^7
+
+        Here `M` is a module over the Ore ring `\mathbb F_q[X; \text{Frob}]`
+        and the variable `X` acts on `M` through `f`::
+
+            sage: S.<X> = M.ore_ring()
+            sage: S
+            Ore Polynomial Ring in X over Finite Field in z of size 7^3 twisted by z |--> z^7
+            sage: v = M((1,0))
+            sage: X*v
+            (1, z)
+
+        The argument ``names`` can be used to give chosen names
+        to the vectors in the canonical basis::
+
+            sage: M = f.ore_module(names=('v', 'w'))
+            sage: M.basis()
+            [v, w]
+
+        or even::
+
+            sage: M = f.ore_module(names='e')
+            sage: M.basis()
+            [e0, e1]
+
+        Note that the bracket construction also works::
+
+            sage: M.<v,w> = f.ore_module()
+            sage: M.basis()
+            [v, w]
+            sage: v + w
+            v + w
+
+        We refer to :mod:`sage.modules.ore_module` for a
+        tutorial on Ore modules in SageMath.
+
+        .. SEEALSO::
+
+            :mod:`sage.modules.ore_module`
+        """
+        from sage.modules.ore_module import OreModule
+        return OreModule(self._matrix, self.parent()._ore, names)
+
+    def _test_nonzero_equal(self, tester):
+        pass

sage/modules/free_quadratic_module_integer_symmetric.py

@@ -305,7 +305,7 @@ def IntegralLatticeDirectSum(Lattices, return_embeddings=False):
         [ 0  0  0  0  0  0  0 -1  2 -1  0]
         [ 0  0  0  0  0  0  0  0 -1  2 -1]
         [ 0  0  0  0  0  0  0  0  0 -1  2]
-        sage: [L, phi] = IntegralLatticeDirectSum([L1, L2, L3], True)
+        sage: L, phi = IntegralLatticeDirectSum([L1, L2, L3], True)
         sage: LL3 = L.sublattice(phi[2].image().basis_matrix())
         sage: L3.discriminant() == LL3.discriminant()
         True
@@ -326,7 +326,7 @@ def IntegralLatticeDirectSum(Lattices, return_embeddings=False):
 
         sage: L1 = IntegralLattice(2 * matrix.identity(2), [[1/2, 1/2]])
         sage: L2 = IntegralLattice("A3", [[1, 1, 2]])                                   # needs sage.graphs
-        sage: [L, phi] = IntegralLatticeDirectSum([L1, L2], True)                       # needs sage.graphs
+        sage: L, phi = IntegralLatticeDirectSum([L1, L2], True)                         # needs sage.graphs
         sage: L                                                                         # needs sage.graphs
         Lattice of degree 5 and rank 2 over Integer Ring
         Basis matrix:
@@ -346,7 +346,7 @@ def IntegralLatticeDirectSum(Lattices, return_embeddings=False):
     dims = [L_i.dimension() for L_i in Lattices]
     degrees = [L_i.degree() for L_i in Lattices]
     degree_tot = sum(degrees)
-    sum_degree = [sum(degrees[:i]) for i in range(N+1)]
+    sum_degree = [sum(degrees[:i]) for i in range(N + 1)]
     inner_product_list = [copy(L_i.inner_product_matrix()) for L_i in Lattices]
     IM = matrix.block_diagonal(inner_product_list)
     ambient = FreeQuadraticModule(ZZ,
@@ -392,8 +392,9 @@ def IntegralLatticeGluing(Lattices, glue, return_embeddings=False):
 
     A single lattice can be glued. This is the same as taking an overlattice::
 
-        sage: # needs sage.libs.pari
         sage: from sage.modules.free_quadratic_module_integer_symmetric import IntegralLatticeGluing
+
+        sage: # needs sage.libs.pari
         sage: L1 = IntegralLattice(matrix([[4]]))
         sage: g1 = L1.discriminant_group().gens()[0]
         sage: glue = [[2 * g1]]
@@ -450,7 +451,7 @@ def IntegralLatticeGluing(Lattices, glue, return_embeddings=False):
         sage: g1 = L1.discriminant_group().gens()[0]
         sage: g2 = L2.discriminant_group().gens()[0]
         sage: glue = [[g1, 2 * g2]]
-        sage: [V, phi] = IntegralLatticeGluing([L1, L2], glue, True)
+        sage: V, phi = IntegralLatticeGluing([L1, L2], glue, True)
         sage: V
         Lattice of degree 8 and rank 8 over Integer Ring
         Basis matrix:
@@ -543,7 +544,7 @@ def IntegralLatticeGluing(Lattices, glue, return_embeddings=False):
         sage: D5 = IntegralLattice("D5")
         sage: gA7 = A7.discriminant_group().gens()[0]
         sage: gD5 = D5.discriminant_group().gens()[0]
-        sage: [L, phi] = IntegralLatticeGluing([A7, A7, D5, D5],
+        sage: L, phi = IntegralLatticeGluing([A7, A7, D5, D5],
         ....:                          [[gA7, gA7, gD5, 2 * gD5],
         ....:                          [gA7, 7 * gA7, 2 * gD5, gD5]], True)
         sage: L.determinant()
@@ -557,9 +558,9 @@ def IntegralLatticeGluing(Lattices, glue, return_embeddings=False):
         sage: # needs sage.graphs
         sage: L1 = IntegralLattice("D4", [[1, 1, 0, 0], [0, 1, 1, 0]])
         sage: L2 = IntegralLattice("E6", [[0, 2, 0, 0, 0, 0], [0, 0, 0, 0, 1, 1]])
-        sage: [f1, f2] = L1.discriminant_group().gens()
-        sage: [g1, g2] = L2.discriminant_group().gens()
-        sage: [L, phi] = IntegralLatticeGluing([L1, L2],
+        sage: f1, f2 = L1.discriminant_group().gens()
+        sage: g1, g2 = L2.discriminant_group().gens()
+        sage: L, phi = IntegralLatticeGluing([L1, L2],
         ....:                                  [[f1, g1], [f2, 2 * g2]], True)
         sage: phi[0]
         Free module morphism defined by the matrix
@@ -595,7 +596,7 @@ def IntegralLatticeGluing(Lattices, glue, return_embeddings=False):
         sage: B * L.gram_matrix() * B.transpose() == L1.gram_matrix()
         True
     """
-    [direct_sum, phi] = IntegralLatticeDirectSum(Lattices, return_embeddings=True)
+    direct_sum, phi = IntegralLatticeDirectSum(Lattices, return_embeddings=True)
     N = len(Lattices)
     for g in glue:
         if not len(g) == N:
@@ -735,7 +736,7 @@ class FreeQuadraticModule_integer_symmetric(FreeQuadraticModule_submodule_with_b
         return s
 
     @cached_method
-    def is_even(self):
+    def is_even(self) -> bool:
         r"""
         Return whether the diagonal entries of the Gram matrix are even.
 
@@ -1522,6 +1523,15 @@ class FreeQuadraticModule_integer_symmetric(FreeQuadraticModule_submodule_with_b
             [[(0, 0)], [], [(1, 1), (-1, -1), (0, 1), (0, -1), (1, 0), (-1, 0)]]
             sage: A2.short_vectors(3, up_to_sign_flag=True)                             # needs sage.graphs sage.libs.pari
             [[(0, 0)], [], [(1, 1), (0, 1), (1, 0)]]
+
+        TESTS:
+
+        Check that keyword arguments are passed to :meth:`sage.quadratic_forms.short_vector_list_up_to_length`
+        (:issue:`39848`)::
+
+            sage: A2 = IntegralLattice('A2')                                            # needs sage.graphs
+            sage: A2.short_vectors(3, up_to_sign_flag=False)                            # needs sage.graphs sage.libs.pari
+            [[(0, 0)], [], [(1, 1), (-1, -1), (0, 1), (0, -1), (1, 0), (-1, 0)]]
         """
         p, m = self.signature_pair()
         if p * m != 0:
@@ -1531,8 +1541,9 @@ class FreeQuadraticModule_integer_symmetric(FreeQuadraticModule_submodule_with_b
             e = -2
         from sage.quadratic_forms.quadratic_form import QuadraticForm
         q = QuadraticForm(e * self.gram_matrix())
-        short = q.short_vector_list_up_to_length(n, *kwargs)
-        return [[self(v * self.basis_matrix()) for v in L] for L in short]
+        short = q.short_vector_list_up_to_length(n, **kwargs)
+        # (matrix(L)* B ).rows() is faster than [v * B for v in L]
+        return [[self(r, check=False) for r in matrix(L) * self.basis_matrix()] if L else [] for L in short]
 
     def _fplll_enumerate(self, target=None):
         r"""