oscar-system · lkastner · Mar 10, 2025 · Sep 16, 2024 · Sep 16, 2024 · Sep 17, 2024
diff --git a/Artifacts.toml b/Artifacts.toml
@@ -1,3 +1,11 @@
+[version-1-3-0-files]
+git-tree-sha1 = "231c660234d515a682a698764042cd9dae90361b"
+lazy = true
+
+     [[version-1-3-0-files.download]]
+     sha256 = "cd475445c983883d84a4ac29910d75f8b681ca1a99eb8f18f8164d2caa8704c3"
+     url = "https://github.com/oscar-system/Oscar.jl/releases/download/archive-tag-1/version_1_3_0_files.tar.gz"     
+
 [FTM-1511-03209]
 git-tree-sha1 = "ba4c659df6bba8d746d85628bfedf8b77b77047c"
 lazy = true
@@ -7,12 +15,12 @@ lazy = true
     url = "https://zenodo.org/records/14611045/files/1511-03209.tar.gz"
 
 [QSMDB]
-git-tree-sha1 = "52686066016440cf2e6e286a923aed887658543c"
+git-tree-sha1 = "50dadf750f037e93b4514d91314e1990ff5db090"
 lazy = true
 
      [[QSMDB.download]]
-     sha256 = "2b0a368c07d368f3973352b7f6e856214e25383d2cc3a78c70415afe247a997e"
-     url = "https://github.com/oscar-system/Oscar.jl/releases/download/archive-tag-1/QSMDB-2.tar.gz"     
+     sha256 = "3903c6d7b14cea141ae4f5fd75ac97dca1d846596d6e11becd5f7c643cf69c36"
+     url = "https://github.com/oscar-system/Oscar.jl/releases/download/archive-tag-1/QSMDB-3.tar.gz"     
 
 [gap_extraperfect]
 git-tree-sha1 = "084fa12573e5089ceb3299f9d341f244b415da52"

diff --git a/docs/src/DeveloperDocumentation/changelog.md b/docs/src/DeveloperDocumentation/changelog.md
@@ -85,7 +85,6 @@ labels, and the release notes script will organize them appropriately:
 
 ## Suggestions for formulations
 
-
 In general the description of each change should start with a verb in present
 tense. Here are some more concrete suggestions.
 
@@ -98,7 +97,6 @@ tense. Here are some more concrete suggestions.
 | improvements                  | Improve (performance) of `blub`
 | experimental feature          | Experimental: add support for `bla`
 
-
 ## Updating the changelog
 
 There are two ways to update the changelog: by invoking the script directly, or by triggering

diff --git a/docs/src/DeveloperDocumentation/serialization.md b/docs/src/DeveloperDocumentation/serialization.md
@@ -109,20 +109,32 @@ evaluation.
 There are three pairs of saving and loading functions that are used
 during serialization:
 1. `save_typed_object`, `load_typed_object`
-2. `save_object`, `load_object`
-3. `save_type_params`, `load_type_params`
+2. `save_type_params`, `load_type_params`
+3. `save_object`, `load_object`
+
 
 #### `save_type_object` / `load_type_object`
 
-For the most part these functions should not be touched, they are high level
+These functions should not be touched, they are high level
 functions and are used to (de)serialize the object with its
 type information as well as its data. The data and type nodes are
 set in `save_typed_object` resulting in a "data branch" and "type branch".
-The usage of these functions can be used inside `save_object` / `load_object`
-and `save_type_params` / `load_type_params`. However using `save_typed_object` inside
-a `save_object` implementation will lead to a verbose format and should at some
-point be moved to `save_type_params`. Their implementation can be found in the
-`main.jl` file.
+
+
+#### `save_type_params` / `load_type_params`
+
+The serialization mechanism stores data in the format of a tree, with the
+exception that some nodes may point to a shared reference. The "data branch"
+is anything that is a child node of a data node, whereas the "type branch" is
+any information that is stored in a node that is a child of a type node.
+
+These functions should also not be touched, however they expect an implementation
+of `type_params` whenever saving a type `T`. By default `type_params` will return
+`nothing`. The `type_params` function does a shallow pass through an `obj` of type
+`T` gathering the necessary parameters for serializing `obj`.
+In most cases these parameters are the parameters of the `obj` that uses references.
+For example if `obj` is of type `RingElem` than it is expected that `type_params`
+should contain at least 
 
 #### `save_object` / `load_object`
 
@@ -265,24 +277,6 @@ end
 Note for now `save_typed_object` must be wrapped in either a `save_data_array` or
 `save_data_dict`. Otherwise you will get a key override error.
 
-#### `save_type_params` / `load_type_params`
-
-The serialization mechanism stores data in the format of a tree, with the
-exception that some nodes may point to a shared reference. The "data branch"
-is anything that is a child node of a data node, whereas the "type branch" is
-any information that is stored in a node that is a child of a type node.
-Avoiding type information inside the data branch will lead to a more
-efficient serialization format. When the `uses_params` is set when
-registering the type with [`@register_serialization_type`](@ref)
-(de)serialization will use `save_type_params` / `load_type_params`
-to format the type information.
-In general we expect that implementing a `save_type_params` and
-`load_type_params` should not always be necessary. Many types
-will serialize their types in a similar fashion for example serialization
-of a `FieldElem` will use the `save_type_params` / `load_type_params` from
-`RingElem` since in both cases the only parameter needed for such types
-is their parent.
-
 ### Import helper
 
 When implementing the serialization of a new type in a module that is not

diff --git a/experimental/FTheoryTools/src/AbstractFTheoryModels/attributes.jl b/experimental/FTheoryTools/src/AbstractFTheoryModels/attributes.jl
@@ -880,8 +880,8 @@ Assuming that the first row of the given grading is the grading under Kbar
 Global Tate model over a not fully specified base -- SU(5)xU(1) restricted Tate model based on arXiv paper 1109.3454 Eq. (3.1)
 
 julia> resolutions(m)
-1-element Vector{Vector{Vector}}:
- [[["x", "y", "w"], ["y", "e1"], ["x", "e4"], ["y", "e2"], ["x", "y"]], ["e1", "e4", "e2", "e3", "s"]]
+1-element Vector{Tuple{Vector{Vector{String}}, Vector{String}}}:
+ ([["x", "y", "w"], ["y", "e1"], ["x", "e4"], ["y", "e2"], ["x", "y"]], ["e1", "e4", "e2", "e3", "s"])
 ```
 """
 function resolutions(m::AbstractFTheoryModel)
@@ -955,8 +955,8 @@ Assuming that the first row of the given grading is the grading under Kbar
 Global Tate model over a not fully specified base -- SU(5)xU(1) restricted Tate model based on arXiv paper 1109.3454 Eq. (3.1)
 
 julia> weighted_resolutions(m)
-1-element Vector{Vector{Vector}}:
- [Vector{Vector{Any}}[[["x", "y", "w"], [1, 1, 1]], [["x", "y", "w"], [1, 2, 1]], [["x", "y", "w"], [2, 2, 1]], [["x", "y", "w"], [2, 3, 1]], [["x", "y"], [1, 1]]], ["e1", "e4", "e2", "e3", "s"]]
+1-element Vector{Tuple{Vector{Tuple{Vector{String}, Vector{Int64}}}, Vector{String}}}:
+ ([(["x", "y", "w"], [1, 1, 1]), (["x", "y", "w"], [1, 2, 1]), (["x", "y", "w"], [2, 2, 1]), (["x", "y", "w"], [2, 3, 1]), (["x", "y"], [1, 1])], ["e1", "e4", "e2", "e3", "s"])
 ```
 """
 function weighted_resolutions(m::AbstractFTheoryModel)
@@ -1967,3 +1967,32 @@ function genera_of_components_of_simplified_dual_graph(m::AbstractFTheoryModel)
   @req has_attribute(m, :genus_of_components_of_simplified_dual_graph) "Genera of components of simplified dual graph not known for this model"
   return get_attribute(m, :genus_of_components_of_simplified_dual_graph)
 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
+
+@attr QQMatrix function matrix_rational_quant_transverse(m::AbstractFTheoryModel; check::Bool = true)
+  return matrix_rational(special_flux_family(m, check = check))
+end
+
+@attr QQMatrix function matrix_integral_quant_transverse_nobreak(m::AbstractFTheoryModel)
+  return matrix_integral(special_flux_family(m, not_breaking = true; check = check))
+end
+
+@attr QQMatrix function matrix_rational_quant_transverse_nobreak(m::AbstractFTheoryModel)
+  return matrix_rational(special_flux_family(m, not_breaking = true; check = check))
+end
diff --git a/experimental/FTheoryTools/src/AbstractFTheoryModels/methods.jl b/experimental/FTheoryTools/src/AbstractFTheoryModels/methods.jl
@@ -634,7 +634,7 @@ function set_torsion_sections(m::AbstractFTheoryModel, vs::Vector{Vector{String}
   set_attribute!(m, :torsion_sections => [[f(eval_poly(l, R)) for l in k] for k in vs])
 end
 
-function set_resolutions(m::AbstractFTheoryModel, desired_value::Vector{Vector{Vector}})
+function set_resolutions(m::AbstractFTheoryModel, desired_value::Vector{Tuple{Vector{Vector{String}}, Vector{String}}})
   set_attribute!(m, :resolutions => desired_value)
 end
 
@@ -652,7 +652,7 @@ function set_resolution_zero_sections(m::AbstractFTheoryModel, vs::Vector{Vector
   set_attribute!(m, :resolution_zero_sections => result)
 end
 
-function set_weighted_resolutions(m::AbstractFTheoryModel, desired_value::Vector{Vector{Vector}})
+function set_weighted_resolutions(m::AbstractFTheoryModel, desired_value::Vector{Tuple{Vector{Tuple{Vector{String}, Vector{Int}}}, Vector{String}}})
   set_attribute!(m, :weighted_resolutions => desired_value)
 end
 

diff --git a/experimental/FTheoryTools/src/FTheoryTools.jl b/experimental/FTheoryTools/src/FTheoryTools.jl
@@ -41,6 +41,5 @@ include("FamilyOfG4Fluxes/special_constructors.jl")
 include("Serialization/tate_models.jl")
 include("Serialization/weierstrass_models.jl")
 include("Serialization/hypersurface_models.jl")
-include("Serialization/qsm_models.jl")
 
 include("exports.jl")
diff --git a/experimental/FTheoryTools/src/FamilyOfG4Fluxes/attributes.jl b/experimental/FTheoryTools/src/FamilyOfG4Fluxes/attributes.jl
@@ -24,7 +24,6 @@ A family of G4 fluxes:
   - Elementary quantization checks: not executed
   - Transversality checks: not executed
   - Non-abelian gauge group: breaking pattern not analyzed
-  - Tadpole constraint: not analyzed
 
 julia> model(f_gs) == qsm_model
 true
@@ -57,7 +56,6 @@ A family of G4 fluxes:
   - Elementary quantization checks: not executed
   - Transversality checks: not executed
   - Non-abelian gauge group: breaking pattern not analyzed
-  - Tadpole constraint: not analyzed
 
 julia> matrix_integral(f_gs) == mat_int
 true
@@ -90,7 +88,6 @@ A family of G4 fluxes:
   - Elementary quantization checks: not executed
   - Transversality checks: not executed
   - Non-abelian gauge group: breaking pattern not analyzed
-  - Tadpole constraint: not analyzed
 
 julia> matrix_rational(f_gs) == mat_rat
 true
@@ -126,16 +123,8 @@ A family of G4 fluxes:
   - Elementary quantization checks: satisfied
   - Transversality checks: satisfied
   - Non-abelian gauge group: broken
-  - Tadpole constraint: not analyzed
 
 julia> d3_tadpole_constraint(fgs);
-
-julia> fgs
-A family of G4 fluxes:
-  - Elementary quantization checks: satisfied
-  - Transversality checks: satisfied
-  - Non-abelian gauge group: broken
-  - Tadpole constraint: evaluated
 ```
 """
 @attr QQMPolyRingElem function d3_tadpole_constraint(fgs::FamilyOfG4Fluxes; check::Bool = true)
@@ -150,6 +139,18 @@ A family of G4 fluxes:
   end
 
   # Are intersection numbers known?
+  # TODO: If available and necessary, convert inter_dict.
+  # TODO: This is necessary, because serializing and loading turns NTuple{4, Int64} into Tuple (as of March 5, 2025).
+  # TODO: Once serialization has caught up, this conversion will no longer be needed.
+  if has_attribute(m, :inter_dict) && typeof(get_attribute(m, :inter_dict)) != Dict{NTuple{4, Int64}, ZZRingElem}
+    original_dict = get_attribute(m, :inter_dict)
+    new_dict = Dict{NTuple{4, Int64}, ZZRingElem}()
+    for (key, value) in original_dict
+      new_key = NTuple{4, Int64}(key)
+      new_dict[new_key] = value
+    end
+    set_attribute!(model, :inter_dict, new_dict)
+  end
   inter_dict = get_attribute!(m, :inter_dict) do
     Dict{NTuple{4, Int64}, ZZRingElem}()
   end::Dict{NTuple{4, Int64}, ZZRingElem}

diff --git a/experimental/FTheoryTools/src/FamilyOfG4Fluxes/constructors.jl b/experimental/FTheoryTools/src/FamilyOfG4Fluxes/constructors.jl
@@ -30,7 +30,6 @@ A family of G4 fluxes:
   - Elementary quantization checks: not executed
   - Transversality checks: not executed
   - Non-abelian gauge group: breaking pattern not analyzed
-  - Tadpole constraint: not analyzed
 ```
 """
 function family_of_g4_fluxes(m::AbstractFTheoryModel, mat_int::QQMatrix, mat_rat::QQMatrix; check::Bool = true)
@@ -69,7 +68,7 @@ function Base.show(io::IO, gf::FamilyOfG4Fluxes)
   properties_string = ["A family of G4 fluxes:"]
 
   # Check for elementary quantization checks
-  if has_attribute(gf, :is_well_quantized)
+  if has_attribute(gf, :is_well_quantized) && get_attribute(gf, :is_well_quantized) !== nothing
     if is_well_quantized(gf)
       push!(properties_string, "  - Elementary quantization checks: satisfied")
     else
@@ -80,7 +79,7 @@ function Base.show(io::IO, gf::FamilyOfG4Fluxes)
   end
 
   # Check for transversality checks
-  if has_attribute(gf, :passes_transversality_checks)
+  if has_attribute(gf, :passes_transversality_checks) && get_attribute(gf, :passes_transversality_checks) !== nothing
     if passes_transversality_checks(gf)
       push!(properties_string, "  - Transversality checks: satisfied")
     else
@@ -91,7 +90,7 @@ function Base.show(io::IO, gf::FamilyOfG4Fluxes)
   end
 
   # Check for non-abelian gauge group breaking
-  if has_attribute(gf, :breaks_non_abelian_gauge_group)
+  if has_attribute(gf, :breaks_non_abelian_gauge_group) && get_attribute(gf, :breaks_non_abelian_gauge_group) !== nothing
     if breaks_non_abelian_gauge_group(gf)
       push!(properties_string, "  - Non-abelian gauge group: broken")
     else
@@ -102,11 +101,13 @@ function Base.show(io::IO, gf::FamilyOfG4Fluxes)
   end
 
   # Is the tadpole constrained worked out as polynomial?
-  if has_attribute(gf, :d3_tadpole_constraint)
+  #=
+  if has_attribute(gf, :d3_tadpole_constraint) && get_attribute(gf, :d3_tadpole_constraint) !== nothing
     push!(properties_string, "  - Tadpole constraint: evaluated")
   else
     push!(properties_string, "  - Tadpole constraint: not analyzed")
   end
+  =#
 
   # Print each line separately, to avoid extra line break at the end
   for (i, line) in enumerate(properties_string)

diff --git a/experimental/FTheoryTools/src/FamilyOfG4Fluxes/methods.jl b/experimental/FTheoryTools/src/FamilyOfG4Fluxes/methods.jl
@@ -26,7 +26,6 @@ A family of G4 fluxes:
   - Elementary quantization checks: not executed
   - Transversality checks: not executed
   - Non-abelian gauge group: breaking pattern not analyzed
-  - Tadpole constraint: not analyzed
 
 julia> int_combination = matrix(ZZ, [[3]])
 [3]
@@ -98,7 +97,6 @@ A family of G4 fluxes:
   - Elementary quantization checks: not executed
   - Transversality checks: not executed
   - Non-abelian gauge group: breaking pattern not analyzed
-  - Tadpole constraint: not analyzed
 
 julia> random_flux_instance(fgs, check = false)
 G4-flux candidate

diff --git a/experimental/FTheoryTools/src/FamilyOfG4Fluxes/properties.jl b/experimental/FTheoryTools/src/FamilyOfG4Fluxes/properties.jl
@@ -26,7 +26,6 @@ A family of G4 fluxes:
   - Elementary quantization checks: satisfied
   - Transversality checks: satisfied
   - Non-abelian gauge group: broken
-  - Tadpole constraint: not analyzed
 
 julia> is_well_quantized(gf)
 true
@@ -40,7 +39,6 @@ A family of G4 fluxes:
   - Elementary quantization checks: not executed
   - Transversality checks: not executed
   - Non-abelian gauge group: breaking pattern not analyzed
-  - Tadpole constraint: not analyzed
 
 julia> is_well_quantized(gf2, check = false)
 true
@@ -103,7 +101,6 @@ A family of G4 fluxes:
   - Elementary quantization checks: satisfied
   - Transversality checks: satisfied
   - Non-abelian gauge group: broken
-  - Tadpole constraint: not analyzed
 
 julia> passes_transversality_checks(gf, check = false)
 true
@@ -117,7 +114,6 @@ A family of G4 fluxes:
   - Elementary quantization checks: not executed
   - Transversality checks: not executed
   - Non-abelian gauge group: breaking pattern not analyzed
-  - Tadpole constraint: not analyzed
 
 julia> passes_transversality_checks(gf3)
 true
@@ -169,7 +165,6 @@ A family of G4 fluxes:
   - Elementary quantization checks: satisfied
   - Transversality checks: satisfied
   - Non-abelian gauge group: broken
-  - Tadpole constraint: not analyzed
 
 julia> breaks_non_abelian_gauge_group(gf)
 true
@@ -179,7 +174,6 @@ A family of G4 fluxes:
   - Elementary quantization checks: satisfied
   - Transversality checks: satisfied
   - Non-abelian gauge group: not broken
-  - Tadpole constraint: not analyzed
 
 julia> breaks_non_abelian_gauge_group(gf3)
 false
@@ -193,7 +187,6 @@ A family of G4 fluxes:
   - Elementary quantization checks: not executed
   - Transversality checks: not executed
   - Non-abelian gauge group: breaking pattern not analyzed
-  - Tadpole constraint: not analyzed
 
 julia> breaks_non_abelian_gauge_group(gf4, check = false)
 false