Backports for Oscar 1.0

- Add QQBar docs to the manual #3423
- do not show the OscarInterface banner #3422
- fix bugs in all_OD_infos #3419
- Ep/ Rename Spec to AffineScheme #3345 #3425
- Remove two mentions of Arb_jll #3431
- Tweak epimorphism_from_free_group #3430
- CI: re-enable nightly #3435
- support gen(G::GAPGroup, 0) #3332
- Align all_*_groups methods some more #3433
- Add all_perfect_groups #3434
- Add all_primitive_groups and all_transitive_groups variants taking a single int or int range #3404
- fix a docstring #3436
- Fixes multivariate division #3396
- Docu invariants tori #3428
- Improve docstrings for is_conjugate/is_conjugate_with_data. #3384
- Fix ambient_module(M::SubquoModule) #3448
- Bugfix for printing of affine schemes #3437
- Bugfix for bugfix for printing of affine schemes #3445
- Update OSCAR banner #3410
- Docu invariants lin. red. groups (Lakshmi Ramesh and Wolfram Decker) #3443
- add od_from_atlas_group, od_from_p_subgroup, and helpers #3444
- Unexport normalise #3453
- support group properties for character tables #3449
- add docstrings for acting_group and action_function #3432 (exports are used in new groups code for the book)
- Adjust to renaming of rank(A::FinGenAbGroup) to torsion_free_rank(A::FinGenAbGroup) #3457
- Ensure fp_group(G) transfers group attributes #3464
- Added comment on convention #3467
- Export weierstrass_chart_on_minimal_model and patch transform_to_weierstrass #3458
- Fix a doc signature #3466
- Grading + caching for affine algebra of torus invariants #3469

.github/workflows/CI.yml

@@ -32,7 +32,7 @@ jobs:
           - '1.9'   # to be removed in the near future
           - '1.10'
           - '1.11-nightly'
-          #- 'nightly'
+          - 'nightly'
         group: [ 'short', 'long' ]
         os:
           - ubuntu-latest
@@ -114,7 +114,7 @@ jobs:
           - '1.9'   # to be removed in the near future
           - '1.10'
           - '1.11-nightly'
-          #- 'nightly'
+          - 'nightly'
         os:
           - ubuntu-latest
         depwarn: [ '' ]

Project.toml

@@ -31,7 +31,7 @@ AlgebraicSolving = "0.4.11"
 Distributed = "1.6"
 DocStringExtensions = "0.8, 0.9"
 GAP = "0.10.2"
-Hecke = "0.29.0"
+Hecke = "0.30.0"
 JSON = "^0.20, ^0.21"
 JSON3 = "1.13.2"
 LazyArtifacts = "1.6"
@@ -42,7 +42,7 @@ Preferences = "1"
 Random = "1.6"
 RandomExtensions = "0.4.3"
 Serialization = "1.6"
-Singular = "0.22.3"
+Singular = "0.22.4"
 TOPCOM_jll = "0.17.8"
 UUIDs = "1.6"
 cohomCalg_jll = "0.32.0"

README.md

@@ -14,7 +14,7 @@ Polymake, Antic and Singular.
 OSCAR requires Julia 1.6 or newer. In principle it can be installed and used
 like any other Julia package; doing so will take a couple of minutes:
 
-```julia
+```
 julia> using Pkg
 julia> Pkg.add("Oscar")
 julia> using Oscar
@@ -31,21 +31,13 @@ in the OSCAR manual to learn more on how to contribute to OSCAR.
 
 ## Examples of usage
 
-```julia
+```
 julia> using Oscar
- -----    -----    -----      -      -----
-|     |  |     |  |     |    | |    |     |
-|     |  |        |         |   |   |     |
-|     |   -----   |        |     |  |-----
-|     |        |  |        |-----|  |   |
-|     |  |     |  |     |  |     |  |    |
- -----    -----    -----   -     -  -     -
-
-...combining (and extending) ANTIC, GAP, Polymake and Singular
-Version 1.0.0-rc1 ...
-... which comes with absolutely no warranty whatsoever
-Type: '?Oscar' for more information
-(c) 2019-2024 by The OSCAR Development Team
+  ___   ____   ____    _    ____
+ / _ \ / ___| / ___|  / \  |  _ \   |  Combining ANTIC, GAP, Polymake, Singular
+| | | |\___ \| |     / _ \ | |_) |  |  Type "?Oscar" for more information
+| |_| | ___) | |___ / ___ \|  _ <   |  Manual: https://docs.oscar-system.org
+ \___/ |____/ \____/_/   \_\_| \_\  |  Version 1.0.0-rc1
 
 julia> k, a = quadratic_field(-5)
 (Imaginary quadratic field defined by x^2 + 5, sqrt(-5))
@@ -107,7 +99,7 @@ by Submodule with 1 generator
 
 Of course, the cornerstones are also available directly:
 
-```julia
+```
 julia> C = Polymake.polytope.cube(3);
 
 julia> C.F_VECTOR

docs/doc.main

@@ -57,6 +57,7 @@
         "Nemo/qadic.md",
      ],
      "Nemo/finitefield.md",
+     "Nemo/algebraic.md",
      "Fields/algebraic_closure_fp.md",
   ],
 
@@ -152,6 +153,7 @@
   "Invariant Theory" => [
      "InvariantTheory/intro.md",
      "InvariantTheory/finite_groups.md",
+     "InvariantTheory/tori.md",
      "InvariantTheory/reductive_groups.md",
   ],
 

docs/src/AlgebraicGeometry/AlgebraicSets/AffineAlgebraicSet.md

@@ -28,7 +28,7 @@ The algebraic set $X = V(x^2+y^2) \subseteq \mathbb{A}^2$ is irreducible over
 $k = \mathbb{R}$. But it is the union of two lines over $K = \mathbb{C}$,
 i.e. $X$ is irreducible but geometrically reducible.
 See
-[`is_irreducible(X::AbsSpec{<:Field, <:MPolyAnyRing})`](@ref) for details.
+[`is_irreducible(X::AbsAffineScheme{<:Field, <:MPolyAnyRing})`](@ref) for details.
 
 ## Rational points
 To study the $k$-points, also called $k$-rational points, of the algebraic set $X$
@@ -97,7 +97,7 @@ algebraic_set(f::MPolyRingElem; check::Bool=true)
 Convert an affine scheme to an affine algebraic set in order to ignore
 its (non-reduced) scheme structure.
 ```@docs
-algebraic_set(X::Spec; check::Bool=true)
+algebraic_set(X::AffineScheme; check::Bool=true)
 ```
 
 ```@docs

docs/src/AlgebraicGeometry/AlgebraicVarieties/AffineVariety.md

@@ -19,7 +19,7 @@ Functionality which is not (yet) provided by a variety-specific implementation,
 ## Constructors
 ```@docs
 variety(I::MPolyIdeal; check=true)
-variety(X::AbsSpec{<:Field}; is_reduced=false, check::Bool=true)
+variety(X::AbsAffineScheme{<:Field}; is_reduced=false, check::Bool=true)
 variety(R::MPolyAnyRing; check=true)
 ```
 

docs/src/AlgebraicGeometry/Schemes/AffineSchemes.md

@@ -17,14 +17,14 @@ defined over the integers, a finite field or algebraic field extensions of ``\ma
 
 ### General constructors
 
-Besides `Spec(R)` for `R` of either one of the types `MPolyRing`, `MPolyQuoRing`, `MPolyLocRing`, or
+Besides `spec(R)` for `R` of either one of the types `MPolyRing`, `MPolyQuoRing`, `MPolyLocRing`, or
 `MPolyQuoLocRing`, we have the following constructors:
 ```@docs
-Spec(R::MPolyRing, I::MPolyIdeal)
-Spec(R::MPolyRing, U::AbsMPolyMultSet)
-Spec(R::MPolyRing, I::MPolyIdeal, U::AbsMPolyMultSet)
+spec(R::MPolyRing, I::MPolyIdeal)
+spec(R::MPolyRing, U::AbsMPolyMultSet)
+spec(R::MPolyRing, I::MPolyIdeal, U::AbsMPolyMultSet)
 ```
-See [`inclusion_morphism(::AbsSpec, ::AbsSpec)`](@ref) for a way to obtain the ideal ``I`` from ``X = \mathrm{Spec}(R, I)``.
+See [`inclusion_morphism(::AbsAffineScheme, ::AbsAffineScheme)`](@ref) for a way to obtain the ideal ``I`` from ``X = \mathrm{Spec}(R, I)``.
 
 ### Affine n-space
 
@@ -36,27 +36,27 @@ affine_space(kk::BRT, var_symbols::Vector{Symbol}) where {BRT<:Ring}
 ### Closed subschemes
 
 ```@docs
-subscheme(X::AbsSpec, f::Vector{<:RingElem})
-subscheme(X::AbsSpec, I::Ideal)
+subscheme(X::AbsAffineScheme, f::Vector{<:RingElem})
+subscheme(X::AbsAffineScheme, I::Ideal)
 ```
 
 ### Intersections
 
 ```@docs
-Base.intersect(X::AbsSpec{BRT, <:Ring}, Y::AbsSpec{BRT, <:Ring}) where {BRT<:Ring}
+Base.intersect(X::AbsAffineScheme{BRT, <:Ring}, Y::AbsAffineScheme{BRT, <:Ring}) where {BRT<:Ring}
 ```
 
 ### Open subschemes
 
 ```@docs
-hypersurface_complement(X::AbsSpec, f::RingElem)
-hypersurface_complement(X::AbsSpec, f::Vector{<:RingElem})
+hypersurface_complement(X::AbsAffineScheme, f::RingElem)
+hypersurface_complement(X::AbsAffineScheme, f::Vector{<:RingElem})
 ```
 
 ### Closure
 
 ```@docs
-closure(X::AbsSpec, Y::AbsSpec)
+closure(X::AbsAffineScheme, Y::AbsAffineScheme)
 ```
 
 
@@ -67,24 +67,24 @@ closure(X::AbsSpec, Y::AbsSpec)
 Most affine schemes in Oscar ``X = \mathrm{Spec}(R)``
 over a ring ``B``, come with an embedding into an
 affine space ``\mathbb{A}_B``.
-More precisely, `ambient_space(X)` is defined for `X = Spec(R)` if `R`
+More precisely, `ambient_space(X)` is defined for `X = spec(R)` if `R`
 is constructed from a polynomial ring.
 In particular ``\mathrm{Spec}(\mathbb{Z})`` or ``\mathrm{Spec}(\mathbb{k})`` for ``\mathbb k``
 a field do not have an ambient affine space.
 
 ```@docs
-ambient_space(X::AbsSpec)
+ambient_space(X::AbsAffineScheme)
 ```
 
 ### Other attributes
 
 ```@docs
-base_ring(X::AbsSpec)
-codim(X::AbsSpec)
-ambient_embedding(X::AbsSpec)
-dim(X::AbsSpec)
-name(X::AbsSpec)
-OO(X::AbsSpec)
+base_ring(X::AbsAffineScheme)
+codim(X::AbsAffineScheme)
+ambient_embedding(X::AbsAffineScheme)
+dim(X::AbsAffineScheme)
+name(X::AbsAffineScheme)
+OO(X::AbsAffineScheme)
 ```
 
 ### Type getters
@@ -97,16 +97,16 @@ source code for details.
 ## Properties
 
 ```@docs
-is_open_embedding(X::AbsSpec, Y::AbsSpec)
-is_closed_embedding(X::AbsSpec, Y::AbsSpec)
-isempty(X::AbsSpec)
-is_subscheme(X::AbsSpec, Y::AbsSpec)
+is_open_embedding(X::AbsAffineScheme, Y::AbsAffineScheme)
+is_closed_embedding(X::AbsAffineScheme, Y::AbsAffineScheme)
+isempty(X::AbsAffineScheme)
+is_subscheme(X::AbsAffineScheme, Y::AbsAffineScheme)
 ```
 
 
 ## Methods
 ```@docs
-tangent_space(X::AbsSpec{<:Field}, P::AbsAffineRationalPoint)
+tangent_space(X::AbsAffineScheme{<:Field}, P::AbsAffineRationalPoint)
 ```
 ### Comparison
 
@@ -119,5 +119,5 @@ For ``X`` and ``Y`` with different ambient affine space `X==Y` is always `false`
 ### Auxiliary methods
 
 ```@docs
-is_non_zero_divisor(f::RingElem, X::AbsSpec)
+is_non_zero_divisor(f::RingElem, X::AbsAffineScheme)
 ```

docs/src/AlgebraicGeometry/Schemes/ArchitectureOfAffineSchemes.md

@@ -30,7 +30,7 @@ The latter function must return a vector ``v = (a_1,\dots, a_r)``
 of elements in ``R`` such that ``f = a_1 \cdot g_1 + \dots + a_r \cdot g_r``
 where ``g_1,\dots,g_r`` is the set of `gens(I)`. When ``f`` does
 not belong to ``I``, it must error. Note that the ring returned by
-`quo` must again be admissible for the `AbsSpec` interface.
+`quo` must again be admissible for the `AbsAffineScheme` interface.
 
 With a view towards the use of the `ambient_coordinate_ring(X)` for computations,
 it is customary to also implement
@@ -83,68 +83,68 @@ Note that the morphism ``P → R`` is induced by natural coercions.
 
 The abstract type for affine schemes is
 ```@docs
-    AbsSpec{BaseRingType, RingType<:Ring}
+    AbsAffineScheme{BaseRingType, RingType<:Ring}
 ```
 For any concrete instance of this type, we require the following
 functions to be implemented:
-- `base_ring(X::AbsSpec)`,
-- `OO(X::AbsSpec)`.
+- `base_ring(X::AbsAffineScheme)`,
+- `OO(X::AbsAffineScheme)`.
 
 A concrete instance of this type is
 ```@docs
-    Spec{BaseRingType, RingType}
+    AffineScheme{BaseRingType, RingType}
 ```
 It provides an implementation of affine schemes for rings ``R`` of type
 `MPolyRing`, `MPolyQuoRing`, `MPolyLocRing`, and `MPolyQuoLocRing`
 defined over the integers or algebraic field extensions of ``\mathbb Q``.
 This minimal implementation can be used internally, when deriving new
-concrete types `MySpec<:AbsSpec` such as, for instance,
+concrete types `MyAffineScheme<:AbsAffineScheme` such as, for instance,
 group schemes, toric schemes, schemes of a particular dimension
 like curves and surfaces, etc. To this end, one has to store
-an instance `Y` of `Spec` in `MySpec` and implement the methods
+an instance `Y` of `AffineScheme` in `MyAffineScheme` and implement the methods
 ```
-    underlying_scheme(X::MySpec)::Spec # return Y as above
+    underlying_scheme(X::MyAffineScheme)::AffineScheme # return Y as above
 ```
-Then all methods implemented for `Spec` are automatically
-forwarded to any instance of `MySpec`.
+Then all methods implemented for `AffineScheme` are automatically
+forwarded to any instance of `MyAffineScheme`.
 
-**Note:** The above method necessarily returns an instance of `Spec`!
-Of course, it can be overwritten for any higher type `MySpec<:AbsSpec` as needed.
+**Note:** The above method necessarily returns an instance of `AffineScheme`!
+Of course, it can be overwritten for any higher type `MyAffineScheme<:AbsAffineScheme` as needed.
 
 
 ## Existing types of affine scheme morphisms and how to derive new types
 
 Any abstract morphism of affine schemes is of the following type:
 ```@docs
-    AbsSpecMor{DomainType<:AbsSpec,
-               CodomainType<:AbsSpec,
+    AbsAffineSchemeMor{DomainType<:AbsAffineScheme,
+               CodomainType<:AbsAffineScheme,
                PullbackType<:Map,
                MorphismType,
                BaseMorType
                }
 ```
 Any such morphism has the attributes `domain`, `codomain` and `pullback`.
-A concrete and minimalistic implementation exist for the type `SpecMor`:
+A concrete and minimalistic implementation exist for the type `AffineSchemeMor`:
 ```@docs
-    SpecMor{DomainType<:AbsSpec,
-            CodomainType<:AbsSpec,
+    AffineSchemeMor{DomainType<:AbsAffineScheme,
+            CodomainType<:AbsAffineScheme,
             PullbackType<:Map
            }
 ```
 This basic functionality consists of
-- `compose(f::AbsSpecMor, g::AbsSpecMor)`,
-- `identity_map(X::AbsSpec)`,
-- `restrict(f::AbsSpecMor, X::AbsSpec, Y::AbsSpec; check::Bool=true)`,
-- `==(f::AbsSpecMor, g::AbsSpecMor)`,
-- `preimage(f::AbsSpecMor, Z::AbsSpec)`.
-In particular, for every concrete instance of a type `MySpec<:AbsSpec` that
-implements `underlying_scheme`, this basic functionality of `SpecMor`
+- `compose(f::AbsAffineSchemeMor, g::AbsAffineSchemeMor)`,
+- `identity_map(X::AbsAffineScheme)`,
+- `restrict(f::AbsAffineSchemeMor, X::AbsAffineScheme, Y::AbsAffineScheme; check::Bool=true)`,
+- `==(f::AbsAffineSchemeMor, g::AbsAffineSchemeMor)`,
+- `preimage(f::AbsAffineSchemeMor, Z::AbsAffineScheme)`.
+In particular, for every concrete instance of a type `MyAffineScheme<:AbsAffineScheme` that
+implements `underlying_scheme`, this basic functionality of `AffineSchemeMor`
 should run naturally.
 
-We may derive higher types of morphisms of affine schemes `MySpecMor<:AbsSpecMor`
-by storing an instance `g` of `SpecMor` inside an instance `f` of
-`MySpecMor` and implementing
+We may derive higher types of morphisms of affine schemes `MyAffineSchemeMor<:AbsAffineSchemeMor`
+by storing an instance `g` of `AffineSchemeMor` inside an instance `f` of
+`MyAffineSchemeMor` and implementing
 ```
-    underlying_morphism(f::MySpecMor)::SpecMor # return g
+    underlying_morphism(f::MyAffineSchemeMor)::AffineSchemeMor # return g
 ```
 For example, this allows us to define closed embeddings.

docs/src/AlgebraicGeometry/Schemes/CoveredSchemeMorphisms.md

@@ -15,9 +15,9 @@ This information is held by a `CoveringMorphism`:
 The basic functionality of `CoveringMorphism`s comprises `domain` and `codomain` which 
 both return a `Covering`, together with 
 ```
-    getindex(f::CoveringMorphism, U::AbsSpec)
+    getindex(f::CoveringMorphism, U::AbsAffineScheme)
 ```
-which for ``U = U_i`` returns the `AbsSpecMor` ``f_i : U_i \to V_{F(i)}``.
+which for ``U = U_i`` returns the `AbsAffineSchemeMor` ``f_i : U_i \to V_{F(i)}``.
 
 Note that, in general, neither the `domain` nor the `codomain` of the `covering_morphism` of 
 `f : X \to Y` need to coincide with the `default_covering` of ``X``, respectively ``Y``. 
@@ -34,8 +34,8 @@ interface.
 ```
 For the user's convenience, also the domain and codomain 
 of the underlying `covering_morphism` are forwarded as `domain_covering` and 
-`codomain_covering`, respectively, together with `getindex(phi::CoveringMorphism, U::AbsSpec)` 
-as `getindex(f::AbsCoveredSchemeMorphism, U::AbsSpec)`.
+`codomain_covering`, respectively, together with `getindex(phi::CoveringMorphism, U::AbsAffineScheme)` 
+as `getindex(f::AbsCoveredSchemeMorphism, U::AbsAffineScheme)`.
 
 The minimal concrete type of an `AbsCoveredSchemeMorphism` which 
 implements this interface, is `CoveredSchemeMorphism`.
@@ -81,12 +81,12 @@ there is no need to realize the full `covering_morphism` of ``f``.
 In order to facilitate such computations as lazy as possible, there are various fine-grained 
 entry points and caching mechanisms to realize ``f`` on open subsets:
 ```@docs
-    realize_on_patch(Phi::MorphismFromRationalFunctions, U::AbsSpec)
-    realize_on_open_subset(Phi::MorphismFromRationalFunctions, U::AbsSpec, V::AbsSpec)
-    realization_preview(Phi::MorphismFromRationalFunctions, U::AbsSpec, V::AbsSpec)
-    random_realization(Phi::MorphismFromRationalFunctions, U::AbsSpec, V::AbsSpec)
-    cheap_realization(Phi::MorphismFromRationalFunctions, U::AbsSpec, V::AbsSpec)
-    realize_maximally_on_open_subset(Phi::MorphismFromRationalFunctions, U::AbsSpec, V::AbsSpec)
+    realize_on_patch(Phi::MorphismFromRationalFunctions, U::AbsAffineScheme)
+    realize_on_open_subset(Phi::MorphismFromRationalFunctions, U::AbsAffineScheme, V::AbsAffineScheme)
+    realization_preview(Phi::MorphismFromRationalFunctions, U::AbsAffineScheme, V::AbsAffineScheme)
+    random_realization(Phi::MorphismFromRationalFunctions, U::AbsAffineScheme, V::AbsAffineScheme)
+    cheap_realization(Phi::MorphismFromRationalFunctions, U::AbsAffineScheme, V::AbsAffineScheme)
+    realize_maximally_on_open_subset(Phi::MorphismFromRationalFunctions, U::AbsAffineScheme, V::AbsAffineScheme)
     realize(Phi::MorphismFromRationalFunctions)
 ```
 

docs/src/AlgebraicGeometry/Schemes/CoveredSchemes.md

@@ -65,7 +65,7 @@ Every element $U$ of the `affine_charts` of $D$ is either
 
   * directly an element of the `affine_charts` of $C$;
   * a `PrincipalOpenSubset` with some ancestor in the `affine_charts` of $C$; 
-  * a `SimplifiedSpec` with some original in the `affine_charts` of $C$.
+  * a `SimplifiedAffineScheme` with some original in the `affine_charts` of $C$.
 
 In all these cases, the affine subsets in the refinements form a tree and thus remember 
 their origins and ambient spaces. In particular, affine patches and also their gluings can be recycled