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"""
@@ -1662,6 +1677,15 @@ function reduction_to_pos_char(X::EllipticSurface, red_map::Map)
  end::Tuple{<:Map, <:Map}
 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 = get_attribute(X, :reduction_to_pos_char)
+ 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"""
  basis_representation(X::EllipticSurface, D::WeilDivisor)
 
@@ -1677,11 +1701,12 @@ function basis_representation(X::EllipticSurface, D::WeilDivisor)
  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))
+ red_dict = IdDict{AbsWeilDivisor, AbsWeilDivisor}(D=>_reduce_as_prime_divisor(bc, D) for D in basis_ambient)
+ #red_dict_inv = IdDict{AbsWeilDivisor, AbsWeilDivisor}(D=>E for (E, D) in red_dict)
+ 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,6 +1719,32 @@ function basis_representation(X::EllipticSurface, D::WeilDivisor)
  return v*inv(G)
 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
+
 ################################################################################
 #
 # patches for Oscar

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)