Automatic generation of ample classes for elliptic surfaces

src/AlgebraicGeometry/Surfaces/EllipticSurface/EllipticSurface.jl

@@ -890,6 +890,59 @@ algebraic lattice (with quadratic form rescaled by ``-1``).
   return mwl
 end
 
+function ample_class(::Type{QQMatrix}, X::EllipticSurface)
+  NS = algebraic_lattice(X)[3]
+  G = gram_matrix(ambient_space(NS))
+  t = length(trivial_lattice(X)[1])
+  n = rank(NS)
+  r = zero_matrix(QQ, 1, n)
+  r[1:1, 3:t] = matrix(QQ,1,t-2, ones(Int,t-2))*inv(G[3:t,3:t])
+  r = r*denominator(r)
+  # a nef and big class, pullback of an ample class of the weierstrass model
+  h = zero_matrix(QQ, 1, n)
+  h[1,1] = 3
+  h[1,2] = 1
+  v = 5*h + r
+  while (inner_product(ambient_space(NS), v, v)[1,1]<=0
+         || !isempty(short_vectors_iterator(orthogonal_submodule(NS, v), 2))
+         || length(separating_hyperplanes(NS, h, v, -2)) != 0
+        )
+    add!(v, h)
+  end
+  return v
+end 
+
+
+"""
+    is_nef(X::EllipticSurface, f::QQMatrix)
+
+Return if `f` is nef. 
+
+# Arguments
+- `f::QQMatrix` -- a vector given with respect to the ambient space of the algebraic lattice of ``X``
+"""
+function is_nef(X::EllipticSurface, f::QQMatrix)
+  # We do not need to know generators of the Mordell-Weil group for this.s
+  NS = algebraic_lattice(X)[3]
+  V = ambient_space(NS)
+  f_sq = inner_product(V, f, f)[1,1]
+  f_sq >= 0 || return false 
+  a = ample_class(QQMatrix, X) 
+  fa = inner_product(V, f, a)[1,1]
+  fa > 0 || return false  # not in the positive cone
+  if f_sq == 0 
+    # https://arxiv.org/abs/2210.01328
+    # Shimada: Mordell-Weil groups and automorphism groups of elliptic K3 surfaces
+    # Proposition 3.3 
+    af = a + fa*f
+  else 
+    af = f
+  end
+  return length(separating_hyperplanes(NS, a, af, -2))==0
+end
+
+is_nef(X::EllipticSurface, v::Vector{QQFieldElem}) = is_nef(X, matrix(QQ, 1, length(v), v))
+
 @doc raw"""
     mordell_weil_torsion(X::EllipticSurface) -> Vector{EllipticCurvePoint}
 

src/AlgebraicGeometry/Surfaces/EllipticSurface/NeighborStep.jl

@@ -167,6 +167,7 @@ function two_neighbor_step(X::EllipticSurface, F::Vector{QQFieldElem})
   F0 = zeros(QQ,degree(NS)); F0[1]=1
 
   @req inner_product(V, F, F0) == 2 "not a 2-neighbor"
+  @req is_nef(X, F) "not nef"
 
   D1, D, P, l, c = horizontal_decomposition(X, F)
   u = _elliptic_parameter(X, D1, D, P, l, c)

src/AlgebraicGeometry/Surfaces/K3Auto.jl

@@ -155,7 +155,7 @@ function BorcherdsCtx(L::ZZLat, S::ZZLat, weyl::ZZMatrix; compute_OR::Bool=true,
 
   d = exponent(discriminant_group(S))
   Rdual = dual(R)
-  sv = short_vectors(rescale(Rdual,-1), 2, ZZRingElem)
+  sv = short_vectors(Rdual, 2, ZZRingElem)
   # not storing the following for efficiency
   # append!(sv,[(-v[1],v[2]) for v in sv])
   # but for convenience we include zero
@@ -164,7 +164,7 @@ function BorcherdsCtx(L::ZZLat, S::ZZLat, weyl::ZZMatrix; compute_OR::Bool=true,
   prRdelta = [(matrix(QQ, 1, rkR, v[1])*basis_matrix(Rdual),v[2]) for v in sv]
   gramL = change_base_ring(ZZ,gram_matrix(L))
   gramS = change_base_ring(ZZ,gram_matrix(S))
-  deltaR = [change_base_ring(ZZ, matrix(QQ, 1, rkR, v[1])*basis_matrix(R)) for v in short_vectors(rescale(R,-1),2)]
+  deltaR = [change_base_ring(ZZ, matrix(QQ, 1, rkR, v[1])*basis_matrix(R)) for v in short_vectors(R, 2)]
   dualDeltaR = [gramL*transpose(r) for r in deltaR]
   BCtx = BorcherdsCtx(L, S, weyl, SS, R, deltaR, dualDeltaR, prRdelta, membership_test,
                       gramL, gramS, prS, compute_OR)
@@ -851,7 +851,7 @@ end
 
 function _alg58(L::ZZLat, S::ZZLat, R::ZZLat, w::MatrixElem)
   Rdual = dual(R)
-  sv = short_vectors(rescale(Rdual, -1), 2, ZZRingElem)
+  sv = short_vectors(Rdual, 2, ZZRingElem)
   # not storing the following for efficiency
   # append!(sv,[(-v[1],v[2]) for v in sv])
   # but for convenience we include zero
@@ -1318,7 +1318,8 @@ The output is represented with respect to  the basis of `S`.
 
 Note that under our genericity assumptions the kernel of $f$ is of order at most $2$
 and it is equal to $2$ if and only if $S$ is $2$-elementary.
-If an ample class is given, then the generators returned preserve it.
+If an ample class is given, then the generators returned preserve the Weyl chamber
+which contains it. 
 
 This kind of computation can be very expensive. To print progress information
 use `set_verbosity_level(:K3Auto, 2)` or higher.
@@ -1334,7 +1335,7 @@ end
 
 function K3_surface_automorphism_group(S::ZZLat, ample_class::QQMatrix, n::Int=26)
   ample_classS = solve(basis_matrix(S), ample_class; side = :left)
-  L, S, weyl = borcherds_method_preprocessing(S, n, ample=ample_class)
+  L, S, weyl = borcherds_method_preprocessing(S, n, ample=ample_classS)
   return borcherds_method(L, S, weyl, compute_OR=false)[2:end]
 end
 
@@ -1693,7 +1694,7 @@ function weyl_vector(L::ZZLat, U0::ZZLat)
   elseif rank(L)==26
     while true
         R = lll(Hecke.orthogonal_submodule(L,U))
-        m = minimum(rescale(R,-1))
+        m = minimum(R)
         @vprint :K3Auto 1 "found a lattice of minimum $(m) \n"
         if m==4
           # R is isomorphic to the Leech lattice
@@ -1795,8 +1796,9 @@ function borcherds_method_preprocessing(L::ZZLat, S::ZZLat; ample=nothing)
     h = ample*basis_matrix(S)
   end
   # double check
+  @assert inner_product(V, h , h)[1,1] > 0
   Q = orthogonal_submodule(S, lattice(V,h))
-  @assert length(short_vectors(rescale(Q,-1),2))==0
+  @assert length(short_vectors(Q, 2))==0
   if (h*gram_matrix(ambient_space(L))*transpose(weyl))[1,1] < 0
     weyl = -weyl
     u0 = -u0
@@ -1842,7 +1844,7 @@ function ample_class(S::ZZLat)
       @hassert :K3Auto 1 inner_product(V,h,h)[1,1]>0
       # confirm that h is in the interior of a weyl chamber,
       # i.e. check that Q does not contain any -2 vector and h^2>0
-      Q = rescale(Hecke.orthogonal_submodule(S, lattice(V, h)),-1)
+      Q = orthogonal_submodule(S, lattice(V, h))
       @vprint :K3Auto 3 "testing ampleness $(inner_product(V,h,h)[1,1])\n"
       nt = nt+1
       if nt >10
@@ -1899,7 +1901,7 @@ function ample_class(S::ZZLat)
       @assert (h*gram_matrix(S)*transpose(h))[1,1]>0
     end
     h = h*basis_matrix(S)
-    Q = rescale(orthogonal_submodule(S, lattice(V,h)), -1)
+    Q = orthogonal_submodule(S, lattice(V,h))
     if length(short_vectors(Q, 2)) == 0
       return h
     end