diff --git a/experimental/FTheoryTools/docs/src/g4.md b/experimental/FTheoryTools/docs/src/g4.md
index fc3fa12e0e52..108b2aa70a39 100644
--- a/experimental/FTheoryTools/docs/src/g4.md
+++ b/experimental/FTheoryTools/docs/src/g4.md
@@ -87,7 +87,10 @@ Please note that this method may take a long time to execute for involved geomet
 ```@docs
 well_quantized_ambient_space_models_of_g4_fluxes(m::AbstractFTheoryModel; check::Bool = true)
 ```
-Similarly, we have a method for all vertical and well-quantized ambient space $G_4$-flux candidates:
+Similarly, we have a method for all vertical and well-quantized ambient space $G_4$-flux candidates,
+and the vertical and well-quantized ambient space $G_4$-flux candidates, that do not break the non-Abelian
+gauge group.
 ```@docs
 well_quantized_and_vertical_ambient_space_models_of_g4_fluxes(m::AbstractFTheoryModel; check::Bool = true)
+well_quantized_and_vertical_and_no_non_abelian_gauge_group_breaking_ambient_space_models_of_g4_fluxes(m::AbstractFTheoryModel; check::Bool = true)
 ```
diff --git a/experimental/FTheoryTools/src/G4Fluxes/attributes.jl b/experimental/FTheoryTools/src/G4Fluxes/attributes.jl
index c5dba0cc2e6f..1bdf734e3330 100644
--- a/experimental/FTheoryTools/src/G4Fluxes/attributes.jl
+++ b/experimental/FTheoryTools/src/G4Fluxes/attributes.jl
@@ -20,6 +20,7 @@ G4-flux candidate
   - Elementary quantization checks: not executed
   - Tadpole cancellation check: not executed
   - Verticality checks: not executed
+  - Non-Abelian gauge group: breaking pattern not analyzed  
 
 julia> model(g4f)
 Hypersurface model over a concrete base
@@ -46,6 +47,7 @@ G4-flux candidate
   - Elementary quantization checks: not executed
   - Tadpole cancellation check: not executed
   - Verticality checks: not executed
+  - Non-Abelian gauge group: breaking pattern not analyzed
 
 julia> cohomology_class(g4f) == g4_class
 true
diff --git a/experimental/FTheoryTools/src/G4Fluxes/constructors.jl b/experimental/FTheoryTools/src/G4Fluxes/constructors.jl
index 825289708249..985cb780ce95 100644
--- a/experimental/FTheoryTools/src/G4Fluxes/constructors.jl
+++ b/experimental/FTheoryTools/src/G4Fluxes/constructors.jl
@@ -55,12 +55,14 @@ G4-flux candidate
   - Elementary quantization checks: satisfied
   - Tadpole cancellation check: not executed
   - Verticality checks: not executed
+  - Non-Abelian gauge group: breaking pattern not analyzed
 
 julia> g4f2 = g4_flux(qsm_model, g4_class, check = false)
 G4-flux candidate
   - Elementary quantization checks: not executed
   - Tadpole cancellation check: not executed
   - Verticality checks: not executed
+  - Non-Abelian gauge group: breaking pattern not analyzed
 ```
 """
 function g4_flux(m::AbstractFTheoryModel, g4_class::CohomologyClass; check::Bool = true)
@@ -153,6 +155,17 @@ function Base.show(io::IO, g4::G4Flux)
     push!(properties_string, "  - Verticality checks: not executed")
   end
 
+  # Check for non-Abelian gauge group breaking
+  if has_attribute(g4, :breaks_non_abelian_gauge_group)
+    if breaks_non_abelian_gauge_group(g4)
+      push!(properties_string, "  - Non-Abelian gauge group: broken")
+    else
+      push!(properties_string, "  - Non-Abelian gauge group: not broken")
+    end
+  else
+    push!(properties_string, "  - Non-Abelian gauge group: breaking pattern not analyzed")
+  end
+
   # Print each line separately, to avoid extra line break at the end
   for (i, line) in enumerate(properties_string)
     if i == length(properties_string)
diff --git a/experimental/FTheoryTools/src/G4Fluxes/properties.jl b/experimental/FTheoryTools/src/G4Fluxes/properties.jl
index c410950b8f9a..23391e5c8128 100644
--- a/experimental/FTheoryTools/src/G4Fluxes/properties.jl
+++ b/experimental/FTheoryTools/src/G4Fluxes/properties.jl
@@ -32,6 +32,7 @@ G4-flux candidate
   - Elementary quantization checks: not executed
   - Tadpole cancellation check: not executed
   - Verticality checks: not executed
+  - Non-Abelian gauge group: breaking pattern not analyzed
 
 julia> passes_elementary_quantization_checks(g4)
 true
@@ -41,6 +42,7 @@ G4-flux candidate
   - Elementary quantization checks: satisfied
   - Tadpole cancellation check: not executed
   - Verticality checks: not executed
+  - Non-Abelian gauge group: breaking pattern not analyzed
 ```
 """
 @attr Bool function passes_elementary_quantization_checks(g4::G4Flux)
@@ -97,6 +99,7 @@ G4-flux candidate
   - Elementary quantization checks: not executed
   - Tadpole cancellation check: not executed
   - Verticality checks: not executed
+  - Non-Abelian gauge group: breaking pattern not analyzed
 
 julia> passes_verticality_checks(g4)
 true
@@ -106,6 +109,7 @@ G4-flux candidate
   - Elementary quantization checks: not executed
   - Tadpole cancellation check: not executed
   - Verticality checks: satisfied
+  - Non-Abelian gauge group: breaking pattern not analyzed
 ```
 """
 @attr Bool function passes_verticality_checks(g4::G4Flux)
@@ -160,6 +164,7 @@ G4-flux candidate
   - Elementary quantization checks: not executed
   - Tadpole cancellation check: not executed
   - Verticality checks: not executed
+  - Non-Abelian gauge group: breaking pattern not analyzed
 
 julia> passes_tadpole_cancellation_check(g4)
 true
@@ -169,11 +174,12 @@ G4-flux candidate
   - Elementary quantization checks: not executed
   - Tadpole cancellation check: satisfied
   - Verticality checks: not executed
+  - Non-Abelian gauge group: breaking pattern not analyzed
 ```
 """
 @attr Bool function passes_tadpole_cancellation_check(g4::G4Flux)
   m = model(g4)
-  @req (m isa WeierstrassModel || m isa GlobalTateModel || m isa HypersurfaceModel) "Tadpole cancellation checks for  G4-fluxes only supported for Weierstrass, global Tate and hypersurface models"
+  @req (m isa WeierstrassModel || m isa GlobalTateModel || m isa HypersurfaceModel) "Tadpole cancellation checks for G4-fluxes only supported for Weierstrass, global Tate and hypersurface models"
   @req base_space(m) isa NormalToricVariety "Tadpole cancellation checks for G4-flux currently supported only for toric base"
   @req ambient_space(m) isa NormalToricVariety "Tadpole cancellation checks for G4-flux currently supported only for toric ambient space"
   
@@ -187,3 +193,71 @@ G4-flux candidate
   end
   return false
 end
+
+
+@doc raw"""
+    breaks_non_abelian_gauge_group(gf::G4Flux)
+
+G4-fluxes may break the non-Abelian gauge group (cf. [Wei18](@cite)).
+This function verifies if this is the case for the given G4-flux.
+If it does not break any non-Abelian gauge factor, we return 
+`true` and otherwise `false`
+
+```jldoctest; setup = :(Oscar.LazyArtifacts.ensure_artifact_installed("QSMDB", Oscar.LazyArtifacts.find_artifacts_toml(Oscar.oscardir)))
+julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 4))
+Hypersurface model over a concrete base
+
+julia> divs = torusinvariant_prime_divisors(ambient_space(qsm_model));
+
+julia> e1 = cohomology_class(divs[35]);e2 = cohomology_class(divs[32]);e4 = cohomology_class(divs[34]);
+
+julia> u = cohomology_class(divs[33]);v = cohomology_class(divs[30]);pb_Kbar = cohomology_class(sum([divs[k] for k in 1:29]));
+
+julia> g4_class = (-3) // kbar3(qsm_model) * (5 * e1 * e4 + pb_Kbar * (-3 * e1 - 2 * e2 - 6 * e4 + pb_Kbar - 4 * u + v));
+
+julia> g4 = g4_flux(qsm_model, g4_class, check = false)
+G4-flux candidate
+  - Elementary quantization checks: not executed
+  - Tadpole cancellation check: not executed
+  - Verticality checks: not executed
+  - Non-Abelian gauge group: breaking pattern not analyzed
+
+julia> breaks_non_abelian_gauge_group(g4)
+false
+
+julia> g4
+G4-flux candidate
+  - Elementary quantization checks: not executed
+  - Tadpole cancellation check: not executed
+  - Verticality checks: not executed
+  - Non-Abelian gauge group: not broken
+```
+"""
+@attr Bool function breaks_non_abelian_gauge_group(g4::G4Flux)
+  m = model(g4)
+  @req (m isa WeierstrassModel || m isa GlobalTateModel || m isa HypersurfaceModel) "Checks for breaking non-Abelian gauge group factors only supported for Weierstrass, global Tate and hypersurface models"
+  @req base_space(m) isa NormalToricVariety "Checks for breaking non-Abelian gauge group factors currently supported only for toric base"
+  @req ambient_space(m) isa NormalToricVariety "Checks for breaking non-Abelian gauge group factors currently supported only for toric ambient space"
+  
+  # Compute the cohomology class corresponding to the hypersurface equation
+  cy = polynomial(cohomology_class(toric_divisor_class(ambient_space(m), degree(hypersurface_equation(m)))))
+
+  # Identify the cohomology classes of all base divisors
+  n = length(gens(cox_ring(base_space(m))))
+  c_ds = [polynomial(cohomology_class(d)) for d in torusinvariant_prime_divisors(ambient_space(m))[1:n]]
+
+  # Identify the cohomology classes of all exceptional divisors
+  gS = gens(cox_ring(ambient_space(m)))
+  exceptional_divisor_positions = findall(x -> occursin(r"^e\d+$", x), string.(gS))
+  exceptional_divisors = [torusinvariant_prime_divisors(ambient_space(m))[k] for k in exceptional_divisor_positions];
+  c_ei = [polynomial(cohomology_class(d)) for d in exceptional_divisors]
+
+  # now execute the checks if any non-Abelian gauge group factor is broken
+  for i in 1:n
+    for j in 1:length(exceptional_divisors)
+      numb = integrate(cohomology_class(ambient_space(m), polynomial(cohomology_class(g4)) * c_ds[i] * c_ei[j] * cy); check = false)
+      numb!=0 && return true
+    end
+  end
+  return false
+end
diff --git a/experimental/FTheoryTools/src/G4Fluxes/special_attributes.jl b/experimental/FTheoryTools/src/G4Fluxes/special_attributes.jl
index 1f065a773f1a..f3c0f28bdfbc 100644
--- a/experimental/FTheoryTools/src/G4Fluxes/special_attributes.jl
+++ b/experimental/FTheoryTools/src/G4Fluxes/special_attributes.jl
@@ -189,6 +189,7 @@ G4-flux candidate
   - Elementary quantization checks: not executed
   - Tadpole cancellation check: not executed
   - Verticality checks: not executed
+  - Non-Abelian gauge group: breaking pattern not analyzed
 
 julia> passes_elementary_quantization_checks(g4)
 true
@@ -425,6 +426,7 @@ G4-flux candidate
   - Elementary quantization checks: not executed
   - Tadpole cancellation check: not executed
   - Verticality checks: not executed
+  - Non-Abelian gauge group: breaking pattern not analyzed
 
 julia> passes_elementary_quantization_checks(qsm_g4_candidate)
 true
@@ -638,3 +640,347 @@ function well_quantized_and_vertical_ambient_space_models_of_g4_fluxes(m::Abstra
   return res
 
 end
+
+
+
+@doc raw"""
+    well_quantized_and_vertical_and_no_non_abelian_gauge_group_breaking_ambient_space_models_of_g4_fluxes(m::AbstractFTheoryModel; check::Bool = true)::Tuple{QQMatrix, QQMatrix}
+
+Given an F-theory model $m$ defined as hypersurface in a simplicial and
+complete toric base, this method computes a basis of all well-quantized
+and vertical  ambient space $G_4$-fluxes which do not break any non-Abelian
+gauge group factor. The result of this operation is a tuple of two matrices.
+The columns of the first matrix specify those (rational) combinations of
+ambient space $G_4$-fluxes, of which one may only take
+$\mathbb{Z}$-linear combinations without violating flux quantization. The columns
+of the second matrix specify those (rational) combinations of ambient space
+$G_4$-fluxes, for which any rational linear combination satisfies the flux
+quantization condition.
+
+Crucially, this method assumes that $c_2( \widehat{Y}_4)$ is even. Currently, no
+check is conducted and no error raised. Use with care!
+
+Recall that this is relevant in so much as the quantization condition asks to
+verify if the twist of the given $G_4$-flux by $1/2 \cdot c_2( \widehat{Y}_4)$ is
+even. Recall also that it is known that for many F-theory models, $c_2( \widehat{Y}_4)$
+is an even class. For instance, this applies to all F-theory compactifications
+on an elliptically fibered smooth Calabi-Yau 4-fold with a globally defined
+Weierstrass model [CS12](@cite). For instance, this means that all of the
+F-theory QSMs [CHLLT19](@cite) have an even $c_2( \widehat{Y}_4)$.
+
+It can be computationally very demanding to check if a toric variety
+$X$ is complete (and simplicial). The optional argument `check` can be set
+to `false` to skip these tests.
+
+# Examples
+```jldoctest
+julia> B3 = projective_space(NormalToricVariety, 3)
+Normal toric variety
+
+julia> Kbar = anticanonical_divisor_class(B3)
+Divisor class on a normal toric variety
+
+julia> t = literature_model(arxiv_id = "1109.3454", equation = "3.1", base_space = B3, defining_classes = Dict("w"=>Kbar))
+Construction over concrete base may lead to singularity enhancement. Consider computing singular_loci. However, this may take time!
+
+Global Tate model over a concrete base -- SU(5)xU(1) restricted Tate model based on arXiv paper 1109.3454 Eq. (3.1)
+
+julia> res = well_quantized_and_vertical_and_no_non_abelian_gauge_group_breaking_ambient_space_models_of_g4_fluxes(t, check = false);
+
+julia> res[1]
+2 by 0 empty matrix
+
+julia> res[2]
+2 by 0 empty matrix
+```
+
+Here is a more interesting example, in which we verify with our software tool for one particular F-theory QSM, that the
+choice of $G_4$-flux presented in [CHLLT19](@cite), is indeed vertical, satisfies the necessary conditions
+for being well-quantized and does not break the non-Abelian gauge group.
+
+```jldoctest; setup = :(Oscar.LazyArtifacts.ensure_artifact_installed("QSMDB", Oscar.LazyArtifacts.find_artifacts_toml(Oscar.oscardir)))
+julia> qsm_model = literature_model(arxiv_id = "1903.00009", model_parameters = Dict("k" => 2021))
+Hypersurface model over a concrete base
+
+julia> res = well_quantized_and_vertical_and_no_non_abelian_gauge_group_breaking_ambient_space_models_of_g4_fluxes(qsm_model, check = false);
+
+julia> size(res[1])
+(37, 1)
+
+julia> size(res[2])
+(37, 0)
+
+julia> M=res[1];
+
+julia> g4_base = ambient_space_models_of_g4_fluxes(qsm_model, check = false);
+
+julia> g4_classes = [sum(M[i,j]*g4_base[i] for i in 1:length(g4_base)) for j in 1:size(M,2)];
+
+julia> length(g4_classes) == 1
+true
+
+julia> g4_classes[end]
+Cohomology class on a normal toric variety given by 1//30*x4*e2 + 1//15*x4*u + 1//10*x4*e4 + 1//15*x4*e1 + 1//30*x4*w - 11//30*x5*x8 + 1//15*x5*e2 + 2//15*x5*u + 1//5*x5*e4 + 2//15*x5*e1 + 1//15*x5*w - 1//15*x6*x7 - 11//15*x7*x8 + 2//15*x7*e2 + 4//15*x7*u + 2//5*x7*e4 + 4//15*x7*e1 + 2//15*x7*w - 8//15*x8^2 - 8//15*x8*x9 + 2//15*x8*e2 + 4//15*x8*u + 2//5*x8*e4 + 4//15*x8*e1 + 2//15*x8*w - 2//15*x9^2 + 1//15*x9*e2 + 2//15*x9*u + 1//5*x9*e4 + 2//15*x9*e1 + 1//15*x9*w - 1//6*e1*w
+
+julia> g4_candidate = g4_flux(qsm_model, g4_classes[end], check = false);
+
+julia> passes_elementary_quantization_checks(g4_candidate)
+true
+
+julia> passes_verticality_checks(g4_candidate)
+true
+
+julia> breaks_non_abelian_gauge_group(g4_candidate)
+false
+
+julia> c = [60, 51, 90, 0, 24, 51, -24, 45, 30, 0, -48, 90, -57, 60, 30, 15, 120, 0, -60, 0, -720, -420, -270, -60, -2190];
+
+julia> qsm_g4_candidate = g4_flux(qsm_model, sum(c[i]*g4_classes[i] for i in 1:length(g4_classes)), check = false)
+G4-flux candidate
+  - Elementary quantization checks: not executed
+  - Tadpole cancellation check: not executed
+  - Verticality checks: not executed
+  - Non-Abelian gauge group: breaking pattern not analyzed
+
+julia> passes_elementary_quantization_checks(qsm_g4_candidate)
+true
+
+julia> passes_verticality_checks(qsm_g4_candidate)
+true
+
+julia> breaks_non_abelian_gauge_group(qsm_g4_candidate)
+false
+```
+"""
+function well_quantized_and_vertical_and_no_non_abelian_gauge_group_breaking_ambient_space_models_of_g4_fluxes(m::AbstractFTheoryModel; check::Bool = true)::Tuple{QQMatrix, QQMatrix}
+
+  # (1) Entry checks
+  @req base_space(m) isa NormalToricVariety "Computation of well-quantized G4-fluxes only supported for toric base and ambient spaces"
+  @req dim(ambient_space(m)) == 5 "Computation of well-quantized G4-fluxes only supported for 5-dimensional toric ambient spaces"
+  if check
+    @req is_complete(ambient_space(m)) "Computation of well-quantized G4-fluxes only supported for complete toric ambient spaces"
+    @req is_simplicial(ambient_space(m)) "Computation of well-quantized G4-fluxes only supported for simplicial toric ambient space"
+  end
+  if has_attribute(m, :well_quantized_and_vertical_and_no_non_abelian_gauge_group_breaking_ambient_space_models_of_g4_fluxes)
+    return get_attribute(m, :well_quantized_and_vertical_and_no_non_abelian_gauge_group_breaking_ambient_space_models_of_g4_fluxes)
+  end
+
+
+  # (2) Compute data, that is frequently used by the sophisticated intersection product below
+  S = cox_ring(ambient_space(m))
+  gS = gens(cox_ring(ambient_space(m)))
+  linear_relations = matrix(QQ, matrix(ZZ, rays(ambient_space(m))))
+  scalings = [c.coeff for c in S.d]
+  mnf = Oscar._minimal_nonfaces(ambient_space(m))
+  sr_ideal_pos = [Vector{Int}(Polymake.row(mnf, i)) for i in 1:Polymake.nrows(mnf)]
+  data = (
+    S = S,
+    gS = gS,
+    linear_relations = linear_relations,
+    scalings = scalings,
+    sr_ideal_pos = sr_ideal_pos
+  )
+
+
+  # (3) Are intersection numbers known?
+  inter_dict = Dict{NTuple{4, Int64}, ZZRingElem}()
+  s_inter_dict = Dict{String, ZZRingElem}()
+  if has_attribute(m, :inter_dict)
+    inter_dict = get_attribute(m, :inter_dict)
+  end
+  if has_attribute(m, :s_inter_dict)
+    s_inter_dict = get_attribute(m, :s_inter_dict)
+  end
+
+
+  # (4) Obtain critical information - this may take significant time!
+  ambient_space_flux_candidates_basis = ambient_space_models_of_g4_fluxes(m, check = check)
+  list_of_base_divisor_pairs_to_be_considered = Oscar._ambient_space_base_divisor_pairs_to_be_considered(m)
+  ambient_space_flux_candidates_basis_indices = get_attribute(m, :ambient_space_models_of_g4_fluxes_indices)
+  list_of_divisor_pairs_to_be_considered = Oscar._ambient_space_divisor_pairs_to_be_considered(m)
+
+
+  # (5) The following is fragile, but hopefully is a starting point
+  exceptional_divisor_positions = findall(x -> occursin(r"^e\d+$", x), string.(gS))
+
+
+  # (6) Work out the relevant intersection numbers to tell if a flux is vertical
+  vertical_and_no_gauge_group_breaking_constraint_matrix = Vector{Vector{QQFieldElem}}()
+  # I have prepared some functionality below, regarding the case that this matrix should have rational entries.
+  # However, I expect that this will not happen as long as the hypersurface in question is smooth.
+  if arxiv_doi(m) == "10.48550/arXiv.1511.03209"
+
+    # Use special intersection theory for special F-theory model. This technology could be extended beyond this one use-case in the future.
+    for i in 1:length(ambient_space_flux_candidates_basis)
+
+      condition = Vector{ZZRingElem}()
+
+      # Compute against pairs of base divisors
+      for j in 1:length(list_of_base_divisor_pairs_to_be_considered)
+        my_tuple = Tuple(sort([ambient_space_flux_candidates_basis_indices[i]..., list_of_base_divisor_pairs_to_be_considered[j]...]))
+        push!(condition, sophisticated_intersection_product(ambient_space(m), my_tuple, hypersurface_equation(m), inter_dict, s_inter_dict, data))
+      end
+
+      # Compute against zero section and base divisor
+      pos_zero_section = findfirst(x -> x == "z", string.(gS))
+      for j in 1:n_rays(base_space(m))
+        my_tuple = Tuple(sort([ambient_space_flux_candidates_basis_indices[i]..., [j, pos_zero_section]...]))
+        push!(condition, sophisticated_intersection_product(ambient_space(m), my_tuple, hypersurface_equation(m), inter_dict, s_inter_dict, data))
+      end
+
+      # Compute against exceptional divisors
+      for j in 1:n_rays(base_space(m))
+        for k in 1:length(exceptional_divisor_positions)
+          my_tuple = Tuple(sort([ambient_space_flux_candidates_basis_indices[i]..., j, exceptional_divisor_positions[k]...]))
+          push!(condition, sophisticated_intersection_product(ambient_space(m), my_tuple, hypersurface_equation(m), inter_dict, s_inter_dict, data))
+        end
+      end
+
+      # Remember the computed condition
+      push!(vertical_and_no_gauge_group_breaking_constraint_matrix, condition)
+
+    end
+
+  else
+  
+    # Cover all other case with generic, but potentially painfully slow methodology.
+    tds = torusinvariant_prime_divisors(ambient_space(m))
+    cds = [cohomology_class(tds[i]) for i in 1:length(tds)]
+    pt_class = cohomology_class(anticanonical_divisor_class(ambient_space(m)))
+    for i in 1:length(ambient_space_flux_candidates_basis)
+
+      condition = Vector{ZZRingElem}()
+
+      # Compute against pairs of base divisors
+      for j in 1:length(list_of_base_divisor_pairs_to_be_considered)
+        my_tuple = Tuple(sort([ambient_space_flux_candidates_basis_indices[i]..., list_of_base_divisor_pairs_to_be_considered[j]...]))
+        if !haskey(inter_dict, my_tuple)
+          class = ambient_space_flux_candidates_basis[i] * cds[list_of_base_divisor_pairs_to_be_considered[j][1]] * cds[list_of_base_divisor_pairs_to_be_considered[j][2]] * pt_class
+          inter_dict[my_tuple] = ZZ(integrate(class))
+        end
+        push!(condition, inter_dict[my_tuple])
+      end
+
+      # Compute against zero section and base divisor
+      zsc = zero_section_class(m)
+      pos_zero_section = findfirst(x -> x == string(polynomial(zsc)), string.([polynomial(x) for x in cds]))
+      @req pos_zero_section !== nothing && pos_zero_section >= 1 "Could not establish position of the zero section"
+      for j in 1:n_rays(base_space(m))
+        my_tuple = Tuple(sort([ambient_space_flux_candidates_basis_indices[i]..., [j, pos_zero_section]...]))
+        if !haskey(inter_dict, my_tuple)  
+          class = ambient_space_flux_candidates_basis[i] * cds[j] * zsc * pt_class
+          inter_dict[my_tuple] = ZZ(integrate(class))
+        end
+        push!(condition, inter_dict[my_tuple])
+
+      end
+
+      # Compute against exceptional divisors
+      for j in 1:n_rays(base_space(m))
+        for k in 1:length(exceptional_divisor_positions)
+          my_tuple = Tuple(sort([ambient_space_flux_candidates_basis_indices[i]..., j, exceptional_divisor_positions[k]...]))
+          if !haskey(inter_dict, my_tuple)
+            class = ambient_space_flux_candidates_basis[i] * cds[j] * cds[exceptional_divisor_positions[k]] * pt_class
+            inter_dict[my_tuple] = ZZ(integrate(class))
+          end
+          push!(condition, inter_dict[my_tuple])
+
+        end
+      end
+
+      # Remember the computed condition
+      push!(vertical_and_no_gauge_group_breaking_constraint_matrix, condition)
+
+    end
+
+  end
+
+
+  # (6) Compute the vertical fluxes as the kernel of the vertical_and_no_gauge_group_breaking_constraint_matrix.
+  # (6) To later tell if those fluxes are properly quantized, we want to parametrize them with integer coefficient only.
+  denom = lcm(unique(vcat([denominator.(k) for k in vertical_and_no_gauge_group_breaking_constraint_matrix]...)))
+  if denom != 1
+    vertical_and_no_gauge_group_breaking_constraint_matrix = denom * vertical_and_no_gauge_group_breaking_constraint_matrix
+  end
+  C_vertical_and_no_gauge_group_breaking = transpose(matrix(ZZ, vertical_and_no_gauge_group_breaking_constraint_matrix))
+  vertical_and_no_gauge_group_breaking_fluxes = nullspace(C_vertical_and_no_gauge_group_breaking)[2]
+
+
+  # (7) Work out the relevant intersection numbers to tell if a flux is well quantized
+  quant_constraint_matrix = Vector{Vector{QQFieldElem}}()
+  # I have prepared some functionality below, regarding the case that this matrix should have rational entries.
+  # However, I expect that this will not happen as long as the hypersurface in question is smooth.
+  if arxiv_doi(m) == "10.48550/arXiv.1511.03209"
+
+    # Use special intersection theory for special F-theory model. This technology could be extended beyond this one use-case in the future.
+    for i in 1:length(ambient_space_flux_candidates_basis)
+      condition = Vector{ZZRingElem}()
+      for j in 1:length(list_of_divisor_pairs_to_be_considered)
+        my_tuple = Tuple(sort([ambient_space_flux_candidates_basis_indices[i]..., list_of_divisor_pairs_to_be_considered[j]...]))
+        push!(condition, sophisticated_intersection_product(ambient_space(m), my_tuple, hypersurface_equation(m), inter_dict, s_inter_dict, data))
+      end
+      push!(quant_constraint_matrix, condition)
+    end
+
+  else
+  
+    # Cover all other case with generic, but potentially painfully slow methodology.
+    tds = torusinvariant_prime_divisors(ambient_space(m))
+    cds = [cohomology_class(tds[i]) for i in 1:length(tds)]
+    pt_class = cohomology_class(anticanonical_divisor_class(ambient_space(m)))
+    for i in 1:length(ambient_space_flux_candidates_basis)
+      condition = Vector{ZZRingElem}()
+      for j in 1:length(list_of_divisor_pairs_to_be_considered)
+        my_tuple = Tuple(sort([ambient_space_flux_candidates_basis_indices[i]..., list_of_divisor_pairs_to_be_considered[j]...]))
+        if !haskey(inter_dict, my_tuple)
+          class = ambient_space_flux_candidates_basis[i] * cds[list_of_divisor_pairs_to_be_considered[j][1]] * cds[list_of_divisor_pairs_to_be_considered[j][2]] * pt_class
+          inter_dict[my_tuple] = ZZ(integrate(class))
+        end
+        push!(condition, inter_dict[my_tuple])
+      end
+      push!(quant_constraint_matrix, condition)
+    end
+
+  end
+  
+  # (8) Convert the quant_constraint_matrix to a ZZ matrix. If necessary, multiply it by a suitable integer.
+  denom = lcm(unique(vcat([denominator.(k) for k in quant_constraint_matrix]...)))
+  if denom != 1
+    quant_constraint_matrix = denom * quant_constraint_matrix
+  end
+  C = transpose(matrix(ZZ, quant_constraint_matrix))
+
+
+  # (9) Work out the well-quantized fluxes as linear combinations of the parametrization of the vertical and no non-Abelian gauge group breaking fluxes
+  C2 = C * vertical_and_no_gauge_group_breaking_fluxes # This is a ZZ-matrix, since we parametrize vertical fluxes with integer coefficients!
+  S, T, U = snf_with_transform(C2)
+  r = rank(S)
+  @req all(k -> !is_zero(S[k,k]), 1:r) "Inconsistency in Smith normal form detected. Please inform the authors."
+  @req all(k -> is_zero(S[k,k]), r+1:min(nrows(S), ncols(S))) "Inconsistency in Smith normal form  detected. Please inform the authors."
+  S_prime = zero_matrix(QQ, ncols(S), ncols(S))
+  for k in 1:min(nrows(S), ncols(S))
+    if k <= r
+      S_prime[k,k] = denom//S[k,k]
+    else
+      S_prime[k,k] = 1
+    end
+  end
+  solution_matrix = U * S_prime
+
+
+  # (10) Finally, we need to re-express those in terms of the original bases.
+  # (10) Rather, we have res now expressed in terms of the basis of vertical and no non-Abelian gauge group breaking fluxes...
+  sol_mat = vertical_and_no_gauge_group_breaking_fluxes * solution_matrix
+  res = (sol_mat[:,1:r], sol_mat[:,r+1:ncols(solution_matrix)])
+
+
+  # (11) Remember computed data
+  set_attribute!(m, :well_quantized_and_vertical_ambient_space_models_of_g4_fluxes, res)
+  set_attribute!(m, :inter_dict, inter_dict)
+  set_attribute!(m, :s_inter_dict, s_inter_dict)
+
+
+  # (12) Finally, return the result
+  return res
+
+end
diff --git a/experimental/FTheoryTools/src/exports.jl b/experimental/FTheoryTools/src/exports.jl
index eba664d5bdf9..bea8b1ac799b 100644
--- a/experimental/FTheoryTools/src/exports.jl
+++ b/experimental/FTheoryTools/src/exports.jl
@@ -35,8 +35,9 @@ export arxiv_version
 export associated_literature_models
 export base_space
 export basis_of_h22
-export blow_up
 export birational_literature_models
+export blow_up
+export breaks_non_abelian_gauge_group
 export calabi_yau_hypersurface
 export chern_class
 export chern_classes
@@ -219,6 +220,7 @@ export weighted_resolutions
 export weights
 export well_quantized_ambient_space_models_of_g4_fluxes
 export well_quantized_and_vertical_ambient_space_models_of_g4_fluxes
+export well_quantized_and_vertical_and_no_non_abelian_gauge_group_breaking_ambient_space_models_of_g4_fluxes
 export zero_section
 export zero_section_class
 export zero_section_index