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)