Cleanup some code related to dim(I) == -inf checks

experimental/Schemes/src/Resolution_structure.jl

@@ -150,8 +150,8 @@ function _exceptional_divisor_non_embedded(f::MixedBlowUpSequence)
   ex_div_list = exceptional_divisor_list(f)
   C = WeilDivisor(scheme(ex_div_list[1]),ZZ)
   for i in 2:length(ex_div_list)
-    dim(ex_div_list[i]) == -inf && continue            # kick out empty ones
-    C = C + weil_divisor(ex_div_list[i])
+    dim(ex_div_list[i]) === -inf && continue            # kick out empty ones
+    C += weil_divisor(ex_div_list[i])
   end
 
   f.exceptional_divisor = C
@@ -165,11 +165,11 @@ function _exceptional_divisor_non_embedded(f::BlowUpSequence)
   C = CartierDivisor(ambient_scheme(ex_div_list[1]),ZZ)
   for i in 1:length(ex_div_list)
 # do we want to introduce is_empty for divisors?
-    dim(ideal_sheaf(ex_div_list[i])) == -inf && continue          # kick out empty ones
+    dim(ideal_sheaf(ex_div_list[i])) === -inf && continue      # kick out empty ones
                                                                # caution: dim(CartierDivisor) is not computed,
                                                                #          but inferred
                                                                #          ==> need to pass to ideal_sheaf first
-    C = C + cartier_divisor(ex_div_list[i])
+    C += cartier_divisor(ex_div_list[i])
   end
 
   f.exceptional_divisor_on_X = C
@@ -190,8 +190,8 @@ function exceptional_locus(f::MixedBlowUpSequence)
                                                     # they might even have the wrong dimension
   C = AlgebraicCycle(scheme(ex_div_list[1]),ZZ)     # ==> we cannot expect to obtain a divisor, only a cycle
   for E in ex_div_list
-    dim(E) != -inf || continue                        # kick out empty ones
-    C = C + algebraic_cycle(E)
+    dim(E) === -inf && continue                     # kick out empty ones
+    C += algebraic_cycle(E)
   end
 
   return C

src/AlgebraicGeometry/Schemes/CoveredSchemes/Objects/Attributes.jl

@@ -165,28 +165,27 @@ has_name(X::AbsCoveredScheme) = has_attribute(X, :name)
 ########################################################################
 # Auxiliary attributes                                                 #
 ########################################################################
-function dim(X::AbsCoveredScheme)
-  if !has_attribute(X, :dim)
-    d = -inf
-    is_equidimensional=true
-    for U in patches(default_covering(X))
-      e = dim(U)
-      if e > d
-        d == -inf || (is_equidimensional=false)
-        d = e
+@attr Union{Int, NegInf} function dim(X::AbsCoveredScheme)
+  d = -inf
+  is_equidimensional=true
+  for U in patches(default_covering(X))
+    e = dim(U)
+    if e > d
+      if d !== -inf
+        is_equidimensional = false
       end
+      d = e
     end
-    set_attribute!(X, :dim, d)
-    if !is_equidimensional
-      # the above is not an honest check for equidimensionality,
-      # because in each chart the output of `dim` is only the
-      # supremum of all components. Thus we can only infer
-      # non-equidimensionality in case this is already visible
-      # from comparing the different charts
-      set_attribute!(X, :is_equidimensional, false)
-    end
   end
-  return get_attribute(X, :dim)::Union{Int, NegInf}
+  if !is_equidimensional
+    # the above is not an honest check for equidimensionality,
+    # because in each chart the output of `dim` is only the
+    # supremum of all components. Thus we can only infer
+    # non-equidimensionality in case this is already visible
+    # from comparing the different charts
+    set_attribute!(X, :is_equidimensional, false)
+  end
+  return d
 end
 
 @attr Any function singular_locus_reduced(X::AbsCoveredScheme)

src/Rings/mpoly-affine-algebras.jl

@@ -151,11 +151,11 @@ julia> L = monomial_basis(A)
 function monomial_basis(A::MPolyQuoRing)
   @req coefficient_ring(A) isa AbstractAlgebra.Field "The coefficient ring must be a field"
   is_finite_dimensional_vector_space(A) || throw(InfiniteDimensionError())
-  I = A.I
-  G = standard_basis(I)
-  if dim(I) == -inf # I is the whole ring
+  if is_trivial(A)
     return elem_type(base_ring(A))[]
   end
+  I = A.I
+  G = standard_basis(I)
   si = Singular.kbase(singular_generators(G, G.ord))
   return gens(MPolyIdeal(base_ring(I), si))
 end

test/Rings/mpolyquo-localizations.jl

@@ -8,7 +8,6 @@
   I = ideal(R, f)
   Q, p = quo(R, I)
   S = Oscar.MPolyComplementOfKPointIdeal(R, [QQ(1), QQ(0), QQ(1), QQ(0)])
-  T = Oscar.MPolyComplementOfKPointIdeal(R, [QQ(0), QQ(0), QQ(0), QQ(0)])
   L, _ = localization(Q, S)
   a = L(x)
   b = L(y)