Two neighbor step in char 0

experimental/Schemes/src/BlowupMorphism.jl

@@ -644,18 +644,18 @@ function produce_object_on_affine_chart(I::StrictTransformIdealSheaf, U::AbsAffi
   f_loc = covering_morphism(f)[U]
   V = codomain(f_loc)
   IE_loc = IE(U)
-  @assert isone(ngens(IE_loc)) "ideal sheaf of exceptional locus is not principal"
-  tot = pullback(f_loc)(J(V))
-  #return saturation_with_index(tot, IE_loc)
   # It is usually better to pass to the simplified covering to do the computations
   simp_cov = simplified_covering(X)
   U_simp = first([V for V in patches(simp_cov) if original(V) === U])
   a, b = identification_maps(U_simp)
-  # This used to be the following line. But we don't use the index, so we 
-  # switch to the more performant version
-  # result, _ = saturation_with_index(pullback(a)(tot), pullback(a)(IE_loc))
-  result = _iterative_saturation(pullback(a)(tot), elem_type(OO(U_simp))[pullback(a)(u) for (u, _) in factor(lifted_numerator(first(gens(IE_loc))))])
-  return pullback(b)(result)
+  tot = pullback(f_loc)(J(V))
+  if isone(ngens(IE_loc))
+    result = _iterative_saturation(pullback(a)(tot), elem_type(OO(U_simp))[pullback(a)(u) for (u, _) in factor(lifted_numerator(first(gens(IE_loc))))])
+    return pullback(b)(result)
+  else
+    result, _ = saturation_with_index(pullback(a)(tot), pullback(a)(IE_loc))
+    return result
+  end
 end
 
 @attr Bool function is_prime(I::StrictTransformIdealSheaf)

experimental/Schemes/src/elliptic_surface.jl

@@ -1220,6 +1220,17 @@ function _section(X::EllipticSurface, P::EllipticCurvePoint)
   @vprint :EllipticSurface 3 "Computing a section from a point on the generic fiber\n"
   weierstrass_contraction(X) # trigger required computations
   PX = _section_on_weierstrass_ambient_space(X, P)
+
+  if !is_zero(P)
+    WC = weierstrass_chart_on_minimal_model(X)
+    U = original_chart(PX)
+    @assert OO(U) === ambient_coordinate_ring(WC)
+    PY = PrimeIdealSheafFromChart(X, WC, ideal(OO(WC), PX(U)))
+    set_attribute!(PY, :name, string("section: (",P[1]," : ",P[2]," : ",P[3],")"))
+    set_attribute!(PY, :_self_intersection, -euler_characteristic(X))
+    return WeilDivisor(PY, check=false)
+  end
+
   for f in X.ambient_blowups
     PX = strict_transform(f , PX)
   end
@@ -1314,7 +1325,11 @@ function _prop217(E::EllipticCurve, P::EllipticCurvePoint, k)
 
   # collect the equations as a matrix
   cc = [[coeff(j, abi) for abi in ab] for j in eqns]
-  M = matrix(B, length(eqns), length(ab), reduce(vcat,cc, init=elem_type(base)[]))
+  mat = reduce(vcat,cc, init=elem_type(base)[])
+  @assert all(is_one(denominator(x)) for x in mat)
+  @assert all(is_constant(numerator(x)) for x in mat)
+  mat2 = [constant_coefficient(numerator(x)) for x in mat]
+  M = matrix(B, length(eqns), length(ab), mat2)
   # @assert M == matrix(base, cc) # does not work if length(eqns)==0
   K = kernel(M; side = :right)
   kerdim = ncols(K)
@@ -1368,7 +1383,8 @@ function linear_system(X::EllipticSurface, P::EllipticCurvePoint, k::Int64)
 
     I = saturated_ideal(defining_ideal(U))
     IP = ideal([x*xd(t)-xn(t),y*yd(t)-yn(t)])
-    issubset(I, IP) || error("P does not define a point on the Weierstrasschart")
+    # Test is disabled for the moment; should eventually be put behind @check!
+    #issubset(I, IP) || error("P does not define a point on the Weierstrasschart")
 
     @assert gcd(xn, xd)==1
     @assert gcd(yn, yd)==1
@@ -1414,7 +1430,7 @@ function two_neighbor_step(X::EllipticSurface, F::Vector{QQFieldElem})
   @assert scheme(parent(u)) === X
   pr = weierstrass_contraction(X)
   WX, _ = weierstrass_model(X)
-  # The following is a cheating version of the command u = pushforward(pr)(u)
+  # The following is a cheating version of the command u = pushforward(pr)(u) (the latter has now been deprecated!)
   u = function_field(WX)(u[weierstrass_chart_on_minimal_model(X)])
   @assert scheme(parent(u)) === weierstrass_model(X)[1]
 
@@ -1568,8 +1584,7 @@ function horizontal_decomposition(X::EllipticSurface, F::Vector{QQFieldElem})
   @assert all(F4[i]>=0 for i in 1:length(basisNS))
   D = D + sum(ZZ(F4[i])*basisNS[i] for i in 1:length(basisNS))
   @assert D<=D1
-  l = Int(l)
-  return D1, D, P, l, c
+  return D1, D, P, Int(l), c
 end
 
 @doc raw"""
@@ -1649,17 +1664,42 @@ function extended_ade(ADE::Symbol, n::Int)
   return -G, kernel(G; side = :left)
 end
 
-# This function allows to store a reduction map to positive characteristic,
-# e.g. for computing intersection numbers.
-function reduction_to_pos_char(X::EllipticSurface, red_map::Map)
-  return get_attribute!(X, :reduction_to_pos_char) do
-    kk0 = base_ring(X)
-    @assert domain(red_map) === kk0
-    kkp = codomain(red_map)
-    @assert characteristic(kkp) > 0
-    _, result = base_change(red_map, X)
-    return red_map, result
-  end::Tuple{<:Map, <:Map}
+########################################################################
+# Reduction to positive characteristic
+#
+# We allow to store a reduction of an elliptic surface `X` to positive
+# characteristic. The user needs to know what they're doing here! 
+#
+# The functionality can be made available by specifying a reduction 
+# map for the `base_ring` (actually a field) of `X` to a field of 
+# positive characteristic. This can then be stored in `X` via 
+# `set_good_reduction_map!`. The latter unlocks certain features such 
+# as computation of intersection numbers in positive characteristic.
+########################################################################
+function set_good_reduction_map!(X::EllipticSurface, red_map::Map)
+  has_attribute(X, :good_reduction_map) && error("reduction map has already been set")
+  kk0 = base_ring(X)
+  @assert domain(red_map) === kk0
+  kkp = codomain(red_map)
+  @assert characteristic(kkp) > 0
+  set_attribute!(X, :good_reduction_map=>red_map)
+end
+
+@attr AbsCoveredSchemeMorphism function good_reduction(X::EllipticSurface)
+  is_zero(characteristic(base_ring(X))) || error("reduction to positive characteristic is only possible from characteristic zero")
+  has_attribute(X, :good_reduction_map) || error("no reduction map is available; please set it manually via `set_good_reduction_map!`")
+  red_map = get_attribute(X, :good_reduction_map)::Map
+  _, result = base_change(red_map, X)
+  return red_map, result
+end
+
+function reduction_of_algebraic_lattice(X::EllipticSurface)
+  return get_attribute!(X, :reduction_of_algebraic_lattice) do
+    @assert has_attribute(X, :reduction_to_pos_char) "no reduction morphism specified"
+    red_map, bc = good_reduction(X)
+    basis_ambient, _, _= algebraic_lattice(X)
+    return red_dict = IdDict{AbsWeilDivisor, AbsWeilDivisor}(D=>_reduce_as_prime_divisor(bc, D) for D in basis_ambient)
+  end::IdDict
 end
 
 @doc raw"""
@@ -1675,13 +1715,13 @@ function basis_representation(X::EllipticSurface, D::WeilDivisor)
   v = zeros(ZZRingElem, n)
   @vprint :EllipticSurface 3 "computing basis representation of $D\n"
   kk = base_ring(X)
-  if iszero(characteristic(kk)) && has_attribute(X, :reduction_to_pos_char)
-    red_map, bc = get_attribute(X, :reduction_to_pos_char)
-    for i in 1:n
-      @vprintln :EllipticSurface 4 "intersecting with $(i): $(basis_ambient[i])"
-      
-      v[i] = intersect(base_change(red_map, basis_ambient[i]; scheme_base_change=bc), 
-                       base_change(red_map, D; scheme_base_change=bc))
+  if iszero(characteristic(kk)) && has_attribute(X, :good_reduction_map)
+    red_map, bc = good_reduction(X)
+    red_dict = IdDict{AbsWeilDivisor, AbsWeilDivisor}(D=>_reduce_as_prime_divisor(bc, D) for D in basis_ambient)
+    D_red = _reduce_as_prime_divisor(bc, D)
+    for (i, E) in enumerate(basis_ambient)
+      @vprintln :EllipticSurface 4 "intersecting in positive characteristic with $(i): $(basis_ambient[i])"
+      v[i] = intersect(red_dict[E], D_red)
     end
   else
     for i in 1:n
@@ -1694,11 +1734,35 @@ function basis_representation(X::EllipticSurface, D::WeilDivisor)
   return v*inv(G)
 end
 
-################################################################################
-#
-# patches for Oscar
-#
-################################################################################
+### Some functions to do custom pullback of divisors along reduction maps.
+# We assume that primeness is preserved along the reduction. In particular, the 
+# user is responsible for this to hold for all cases used! 
+# They specify the "good reduction" in the end. 
+function _reduce_as_prime_divisor(bc::AbsCoveredSchemeMorphism, D::AbsWeilDivisor)
+  return WeilDivisor(domain(bc), coefficient_ring(D), 
+                     IdDict{AbsIdealSheaf, elem_type(coefficient_ring(D))}(
+                         _reduce_as_prime_divisor(bc, I) => c for (I, c) in coefficient_dict(D)
+                       )
+                    )
+end
+
+function _reduce_as_prime_divisor(bc::AbsCoveredSchemeMorphism, I::AbsIdealSheaf)
+  result = pullback(bc, I)
+  has_attribute(I, :_self_intersection) && set_attribute!(result, :_self_intersection=>
+                                                          (get_attribute(I, :_self_intersection)::Int))
+  return result
+end
+
+function _reduce_as_prime_divisor(bc::AbsCoveredSchemeMorphism, I::PrimeIdealSheafFromChart)
+  U = original_chart(I)
+  bc_cov = covering_morphism(bc)
+  V = __find_chart(U, codomain(bc_cov))
+  IV = I(V)
+  bc_loc = first(maps_with_given_codomain(bc_cov, V))
+  J = pullback(bc_loc)(IV)
+  set_attribute!(J, :is_prime=>true)
+  return PrimeIdealSheafFromChart(domain(bc), domain(bc_loc), J)
+end
 
 
 ########################################################################

src/AlgebraicGeometry/Schemes/Sheaves/IdealSheaves.jl

@@ -345,6 +345,7 @@ end
 end
 
 @attr Bool function has_dimension_leq_zero(I::Ideal)
+  is_one(I) && return true
   return dim(I) <= 0
 end
 
@@ -353,6 +354,7 @@ end
   P = base_ring(R)::MPolyRing
   J = ideal(P, numerator.(gens(I)))
   has_dimension_leq_zero(J) && return true
+  is_one(I) && return true
   return dim(I) <= 0
 end
 
@@ -1691,6 +1693,7 @@ function produce_object(
     algorithm::Symbol=:pullback # Either :pushforward or :pullback
                                    # This determines how to extend through the gluings.
   )
+  U2 === original_chart(F) && return F.P
   # Initialize some local variables
   X = scheme(F)
   OOX = OO(X)