Merge remote-tracking branch 'Matthias/oscar_workerpool' into oscar_workerpool

Author: antonydellavecchia

Artifacts.toml

@@ -1,10 +1,10 @@
 [FTM-1511-03209]
-git-tree-sha1 = "ba4c659df6bba8d746d85628bfedf8b77b77047c"
+git-tree-sha1 = "691925b788610d3de78e8920426cff473be814e5"
 lazy = true
 
     [[FTM-1511-03209.download]]
-    sha256 = "77f85f1e4a2c3b71963bea169b929dd8c1d9b3cf9b28b616f2c91486636acc22"
-    url = "https://zenodo.org/records/14611045/files/1511-03209.tar.gz"
+    sha256 = "0a8086287f30176ae0308ab9cf20cd6bcfb70ad3b24974e1b5dac1fe84427222"
+    url = "https://zenodo.org/records/15085846/files/1511-03209.tar.gz"
 
 [QSMDB]
 git-tree-sha1 = "50dadf750f037e93b4514d91314e1990ff5db090"

docs/oscar_references.bib

@@ -1573,6 +1573,15 @@ @Article{Haz12
   doi           = {10.3390/axioms1020149}
 }
 
+@MastersThesis{Hil99,
+  author        = {Hillebrand, D.},
+  title         = {Triangulierung nulldimensionaler Ideale - Implementierung und Vergleich zweier Algorithmen},
+  note          = {Refereed by Prof. Dr. H.M. Moeller},
+  address       = {Fachbereich Mathematik},
+  year          = {1999},
+  school        = {Universitaet Dortmund}
+}
+
 @Article{Hul22,
   author        = {Hulpke, Alexander},
   title         = {The perfect groups of order up to two million},
@@ -2053,6 +2062,18 @@ @Book{Lan71
   doi           = {10.1007/978-1-4757-1949-9}
 }
 
+@Article{Laz92,
+  author        = {Lazard, D.},
+  title         = {Solving Zero-Dimensional Algebraic Systems},
+  journal       = {Journal of Symbolic Computation},
+  volume        = {13},
+  number        = {2},
+  pages         = {117--131},
+  year          = {1992},
+  month         = feb,
+  doi           = {10.1016/S0747-7171(08)80086-7}
+}
+
 @PhDThesis{Lev05,
   author        = {Viktor Levandovskyy},
   title         = {Non-commutative Computer Algebra for polynomial algebras: Gröbner bases, applications and
@@ -2170,6 +2191,18 @@ @Book{Mar18
   doi           = {10.1007/978-3-319-90233-3}
 }
 
+@Article{Moe93,
+  author        = {Moeller, H. Michael},
+  title         = {On Decomposing Systems of Polynomial Equations with Finitely Many Solutions},
+  journal       = {Applicable Algebra in Engineering, Communication and Computing},
+  volume        = {4},
+  number        = {4},
+  pages         = {217--230},
+  year          = {1993},
+  month         = dec,
+  doi           = {10.1007/BF01200146}
+}
+
 @Article{Nik79,
   author        = {Nikulin, V. V.},
   title         = {Integer symmetric bilinear forms and some of their geometric applications},

docs/src/CommutativeAlgebra/ideals.md

@@ -256,9 +256,16 @@ equidimensional_hull(I::MPolyIdeal)
 equidimensional_hull_radical(I::MPolyIdeal)
 ```
 
+### Triangular Decomposition
+
+```@docs
+triangular_decomposition(::MPolyIdeal)
+```
+
+
 ## Homogenization and Dehomogenization
 
-Referring to [KR05](@cite) for definitions and technical details, we discuss homogenization and dehomogenization in the context of $\mathbb Z^m$-gradings. 
+Referring to [KR05](@cite) for definitions and technical details, we discuss homogenization and dehomogenization in the context of $\mathbb Z^m$-gradings.
 
 ```@docs
 homogenizer(P::MPolyRing{T}, h::VarName; pos::Int=1+ngens(P))  where T

docs/src/Groups/action.md

@@ -69,13 +69,26 @@ orbit(G::PermGroup, omega)
 orbits(Omega::T) where T <: GSetByElements{TG} where TG <: GAPGroup
 is_transitive(Omega::GSet)
 transitivity(Omega::GSet)
+rank_action(Omega::GSet)
+is_primitive(Omega::GSet)
+is_regular(Omega::GSet)
+is_semiregular(Omega::GSet)
+```
+
+## Block systems of a G-set
+
+If we have a G-set $\Omega$, a *block system* of $\Omega$ is a partition that is invariant under the action of the associated group.
+The group action on $\Omega$ induces a natural action on such a partition.
+
+When calling these methods with a `GSet` as the argument, we require that the group action is transitive.
+The blocks are returned as Julia `Set` objects.
+Note that this is in contrast to the return type when calling the methods with a `PermGroup` as the argument, in which case the blocks are sorted vectors of integers.
+
+```@docs
 blocks(Omega::GSet)
 maximal_blocks(Omega::GSet)
 minimal_block_reps(Omega::GSet)
 all_blocks(Omega::GSet)
-rank_action(Omega::GSet)
-is_regular(Omega::GSet)
-is_semiregular(Omega::GSet)
 ```
 
 

experimental/FTheoryTools/docs/src/g4.md

@@ -14,6 +14,11 @@ We currently support the following constructor:
 ```@docs
 g4_flux(model::AbstractFTheoryModel, class::CohomologyClass)
 ```
+In addition to this generic constructor, we also support the following special constructor.
+```@docs
+qsm_flux(qsm_model::AbstractFTheoryModel)
+```
+
 
 
 ## Attributes
@@ -100,7 +105,12 @@ replace an involved algebraic cycle.
 
 ```@docs
 chosen_g4_flux_basis(m::AbstractFTheoryModel; check::Bool = true)
-basis_of_h22(v::NormalToricVariety; check::Bool = true)
+basis_of_h22_ambient(m::AbstractFTheoryModel; check::Bool = true)
+basis_of_h22_hypersurface(m::AbstractFTheoryModel; check::Bool = true)
+basis_of_h22_ambient_indices(m::AbstractFTheoryModel; check::Bool = true)
+basis_of_h22_hypersurface_indices(m::AbstractFTheoryModel; check::Bool = true)
+converter_dict_h22_ambient(m::AbstractFTheoryModel; check::Bool = true)
+converter_dict_h22_hypersurface(m::AbstractFTheoryModel; check::Bool = true)
 ```
 
 
@@ -113,7 +123,7 @@ integral or rational combinations of the ambient space models of G4-fluxes, that
 described above. For such families, we currently support the following constructor:
 
 ```@docs
-family_of_g4_fluxes(m::AbstractFTheoryModel, mat_int::QQMatrix, mat_rat::QQMatrix; check::Bool = true)
+family_of_g4_fluxes(m::AbstractFTheoryModel, mat_int::QQMatrix, mat_rat::QQMatrix, offset::Vector{QQFieldElem}; check::Bool = true)
 ```
 
 ### Attributes

experimental/FTheoryTools/src/AbstractFTheoryModels/attributes.jl

@@ -1216,29 +1216,45 @@ function chern_class(m::AbstractFTheoryModel, k::Int; check::Bool = true)
   @req k >= 0 "Chern class index must be non-negative"
   @req k <= dim(ambient_space(m)) - 1 "Chern class index must not exceed dimension of the space"
 
-  # Check if we can compute the Chern classes for the toric ambient space
-  if check
-    @req is_smooth(ambient_space(m)) && is_complete(ambient_space(m)) "The Chern classes of the tangent bundle of the toric ambient space are only supported if the toric ambient space is smooth and complete"
-  end
+  # CAREFUL: The code below works ONLY for hypersurfaces in toric spaces.
+  # CAREFUL: It represents the Chern classes of the hypersurface by - so I believe canonical - counterparts in the toric ambient space.
+  # CAREFUL: Those counterparts must be restricted to the hypersurface to truly represent the Chern class in question.
+  # CAREFUL: Currently, we only integrate those Chern classes against the hypersurface, which automatically executes the restriction in question.
 
   # If thus far, no non-trivial Chern classes have been computed for this toric variety, add an "empty" vector
   if !has_attribute(m, :chern_classes)
     cs = Vector{Union{Nothing,CohomologyClass}}(nothing, dim(ambient_space(m)))
     cs[1] = cohomology_class(ambient_space(m), one(cohomology_ring(ambient_space(m), check = check)))
-    cy = cohomology_class(toric_divisor_class(ambient_space(m), degree(hypersurface_equation(m))))
-    cs[2] = chern_class(ambient_space(m), 1, check = check) - cy
+    diff = degree(leading_term(hypersurface_equation(m))) - sum(cox_ring(ambient_space(m)).d)
+    coeffs_list = coefficients(toric_divisor(toric_divisor_class(ambient_space(m), diff)))
+    indets = [lift(g) for g in gens(cohomology_ring(ambient_space(m), check = check))]
+    poly = sum(QQ(coeffs_list[k]) * indets[k] for k in 1:length(indets))
+    cs[2] = CohomologyClass(ambient_space(m), cohomology_ring(ambient_space(m), check = check)(poly))
     set_attribute!(m, :chern_classes, cs)
   end
 
+  # Check if we can compute the Chern classes for the toric ambient space
+  if check
+    @req is_smooth(ambient_space(m)) && is_complete(ambient_space(m)) "The Chern classes of the tangent bundle of the toric ambient space are only supported if the toric ambient space is smooth and complete"
+  end
+
   # Check if the Chern class in question is known
   cs = get_attribute(m, :chern_classes)::Vector{Union{Nothing,CohomologyClass}}
   if cs[k+1] !== nothing
     return cs[k+1]::CohomologyClass
   end
-
   # Chern class is not known, so compute and return it...
-  cy = cohomology_class(toric_divisor_class(ambient_space(m), degree(hypersurface_equation(m))))
-  cs[k+1] = chern_class(ambient_space(m), k, check = check) - cy * chern_class(m, k-1; check = check)
+  #cy = cohomology_class(toric_divisor_class(ambient_space(m), degree(hypersurface_equation(m))))
+  #cs[k+1] = chern_class(ambient_space(m), k, check = check) - cy * chern_class(m, k-1; check = check)
+  d = toric_divisor(toric_divisor_class(ambient_space(m), degree(leading_term(hypersurface_equation(m)))))
+  indets = [lift(g) for g in gens(cohomology_ring(ambient_space(m), check = check))]
+  coeff_ring = coefficient_ring(ambient_space(m))
+  poly = sum(coeff_ring(coefficients(d)[k]) * indets[k] for k in 1:length(indets))
+  cy = CohomologyClass(ambient_space(m), cohomology_ring(ambient_space(m), check = check)(poly))
+  ck_ambient = chern_class(ambient_space(m), k, check = check)
+  ckm1 = chern_class(m, k-1, check = check)
+  new_poly = lift(polynomial(ck_ambient)) - lift(polynomial(cy)) * lift(polynomial(ckm1))
+  cs[k+1] = CohomologyClass(ambient_space(m), cohomology_ring(ambient_space(m), check = check)(new_poly))
   set_attribute!(m, :chern_classes, cs)
   return cs[k+1]
 end
@@ -1973,14 +1989,6 @@ end
 ### (5) Attributes for flux families (not exported, rather for serialization overhaul)
 ######################################################################################
 
-@attr QQMatrix function matrix_integral_quant(m::AbstractFTheoryModel; check::Bool = true)
-  return matrix_integral(well_quantized_ambient_space_models_of_g4_fluxes(m, check = check))
-end
-
-@attr QQMatrix function matrix_rational_quant(m::AbstractFTheoryModel; check::Bool = true)
-  return matrix_rational(well_quantized_ambient_space_models_of_g4_fluxes(m, check = check))
-end
-
 @attr QQMatrix function matrix_integral_quant_transverse(m::AbstractFTheoryModel; check::Bool = true)
   return matrix_integral(special_flux_family(m, check = check))
 end
@@ -1989,10 +1997,18 @@ end
   return matrix_rational(special_flux_family(m, check = check))
 end
 
-@attr QQMatrix function matrix_integral_quant_transverse_nobreak(m::AbstractFTheoryModel)
+@attr Vector{QQFieldElem} function offset_quant_transverse(m::AbstractFTheoryModel; check::Bool = true)
+  return offset(special_flux_family(m, check = check))
+end
+
+@attr QQMatrix function matrix_integral_quant_transverse_nobreak(m::AbstractFTheoryModel; check::Bool = true)
   return matrix_integral(special_flux_family(m, not_breaking = true; check = check))
 end
 
-@attr QQMatrix function matrix_rational_quant_transverse_nobreak(m::AbstractFTheoryModel)
+@attr QQMatrix function matrix_rational_quant_transverse_nobreak(m::AbstractFTheoryModel; check::Bool = true)
   return matrix_rational(special_flux_family(m, not_breaking = true; check = check))
 end
+
+@attr Vector{QQFieldElem} function offset_quant_transverse_nobreak(m::AbstractFTheoryModel; check::Bool = true)
+  return offset(special_flux_family(m, not_breaking = true; check = check))
+end

experimental/FTheoryTools/src/AbstractFTheoryModels/methods.jl

@@ -911,5 +911,111 @@ function resolve(m::AbstractFTheoryModel, resolution_index::Int)
     push!(blow_up_chain, resolved_model)
 
   end
+
+
+  # For model 1511.03209 and resolution_index = 1, we extend beyond what is currently saved as resolution in our json file.
+  # Namely, we also resolve the ambient space. This is done by the following lines.
+  if has_attribute(m, :arxiv_id) && resolution_index == 1 && arxiv_id(m) == "1511.03209"
+
+    # Additional blowup 1:
+    # Additional blowup 1:
+    # Ambient space has the following rays
+    #x: [0,0,0,-3,1]
+    #y: [0,0,0,2,-1]
+    #z: [0,0,0,0,1]
+    # We add the ray m1: (0,0,0,1,0). This looks like y + z = 2 * m1.
+    # So naively, I think of this as blowing up y^2 = z^2 = 0 and introducing the variable m1. For the strict transform, we thus do
+    # y^2 -> y^2 * m1
+    # z^2 -> z^2 * m1
+    # y * z -> y * z * m1
+    as = ambient_space(resolved_model);
+    bl = domain(blow_up(as, [0,0,0,1,0], coordinate_name = "m1"));
+    f = hypersurface_equation(resolved_model);
+    my_mons = collect(monomials(f));
+    pos_1 = findfirst(k -> k == "y", [string(a) for a in gens(cox_ring(as))])
+    pos_2 = findfirst(k -> k == "z", [string(a) for a in gens(cox_ring(as))])
+    exp_list = [collect(exponents(m))[1] for m in my_mons];
+    my_exps = [[k[pos_1], k[pos_2]] for k in exp_list];
+    @req all(k -> isinteger(sum(k)), my_exps) "Inconsistency encountered in computation of strict transform. Please inform the authors."
+    m_power = [Int(1//2*sum(a)) for a in my_exps]
+    overall_factor = minimum(m_power)
+    new_coeffs = collect(coefficients(f))
+    new_exps = [vcat([exp_list[k], m_power[k] - overall_factor]...) for k in 1:length(exp_list)]
+    my_builder = MPolyBuildCtx(cox_ring(bl))
+    for a in 1:length(new_exps)
+      push_term!(my_builder, new_coeffs[a], new_exps[a])
+    end
+    new_tate_polynomial = finish(my_builder);
+    model_bl = GlobalTateModel(explicit_model_sections(resolved_model), model_section_parametrization(resolved_model), new_tate_polynomial, base_space(resolved_model), bl);
+    set_attribute!(model_bl, :partially_resolved, true)
+    # Additional blowup 2:
+    # Additional blowup 2:
+    # Ambient space has the following rays:
+    # x: [0,0,0,-3,1]
+    # y: [0,0,0,2,-1]
+    # z: [0,0,0,0,1]
+    # m1: [0,0,0,1,0]
+    # We add the ray m2: (0,0,0,-2,1). This looks like 2 * x + z = 3 * m2. For the strict transform, we thus do
+    # x^3 -> x^3 * m2^2
+    # z^3 -> z^3 * m2
+    as = ambient_space(model_bl);
+    bl = domain(blow_up(as, [0,0,0,-2,1], coordinate_name = "m2"));
+    f = hypersurface_equation(model_bl);
+    my_mons = collect(monomials(f));
+    pos_1 = findfirst(k -> k == "x", [string(a) for a in gens(cox_ring(as))])
+    pos_2 = findfirst(k -> k == "z", [string(a) for a in gens(cox_ring(as))])
+    exp_list = [collect(exponents(m))[1] for m in my_mons];
+    my_exps = [[k[pos_1], k[pos_2]] for k in exp_list];
+    @req all(k -> isinteger(sum(k)), my_exps) "Inconsistency encountered in computation of strict transform. Please inform the authors."
+    m_power = [Int(2//3 * a[1] + 1//3 * a[2]) for a in my_exps]
+    overall_factor = minimum(m_power)
+    new_coeffs = collect(coefficients(f))
+    new_exps = [vcat([exp_list[k], m_power[k] - overall_factor]...) for k in 1:length(exp_list)]
+    my_builder = MPolyBuildCtx(cox_ring(bl))
+    for a in 1:length(new_exps)
+      push_term!(my_builder, new_coeffs[a], new_exps[a])
+    end
+    new_tate_polynomial = finish(my_builder);
+    model_bl2 = GlobalTateModel(explicit_model_sections(model_bl), model_section_parametrization(model_bl), new_tate_polynomial, base_space(model_bl), bl);
+    set_attribute!(model_bl2, :partially_resolved, true)
+    # Additional blowup 3:
+    # Additional blowup 3:
+    # Ambient space has the following rays:
+    # x: [0,0,0,-3,1]
+    # y: [0,0,0,2,-1]
+    # z: [0,0,0,0,1]
+    # m1: [0,0,0,1,0]
+    # m2: [0,0,0,-2,1]
+    # We add the ray m3: (0,0,0,-1,1). This looks like m2 + z = 2 * m3. For the strict transform, we thus do
+    # m2^2 -> m2^2 * m3
+    # z^2 -> z^2 * m3
+    as = ambient_space(model_bl2);
+    bl = domain(blow_up(as, [0,0,0,-1,1], coordinate_name = "m3"));
+    f = hypersurface_equation(model_bl2);
+    my_mons = collect(monomials(f));
+    pos_1 = findfirst(k -> k == "m2", [string(a) for a in gens(cox_ring(as))])
+    pos_2 = findfirst(k -> k == "z", [string(a) for a in gens(cox_ring(as))])
+    exp_list = [collect(exponents(m))[1] for m in my_mons];
+    my_exps = [[k[pos_1], k[pos_2]] for k in exp_list];
+    @req all(k -> isinteger(sum(k)), my_exps) "Inconsistency encountered in computation of strict transform. Please inform the authors."
+    m_power = [Int(1//2 * sum(a)) for a in my_exps]
+    overall_factor = minimum(m_power)
+    new_coeffs = collect(coefficients(f))
+    new_exps = [vcat([exp_list[k], m_power[k] - overall_factor]...) for k in 1:length(exp_list)]
+    my_builder = MPolyBuildCtx(cox_ring(bl))
+    for a in 1:length(new_exps)
+      push_term!(my_builder, new_coeffs[a], new_exps[a])
+    end
+    new_tate_polynomial = finish(my_builder);
+    model_bl3 = GlobalTateModel(explicit_model_sections(model_bl2), model_section_parametrization(model_bl2), new_tate_polynomial, base_space(model_bl2), bl);
+    set_attribute!(model_bl3, :partially_resolved, true)
+
+    # We confirm that after these steps, we achieve what we desire.
+    @req is_smooth(ambient_space(model_bl3)) "Ambient space not yet smooth. Please inform the authors!"
+    @req is_homogeneous(hypersurface_equation(model_bl3)) "Strict transform is not homogeneous. Please inform the authors!"
+    return model_bl3
+    
+  end
+
   return resolved_model
 end