Fix issue with non-smooth case

Author: Andrew Luo

sage_acsv/asymptotics.py

@@ -796,8 +796,9 @@ def compute_asymptotic_contribution(
 
         valid_set = Restriction(Rf)
         valid_set.setminus(
-            [all_factors[j] for j in range(len(all_factors)) if j not in combo]
+            [all_factors[j].subs(subs_dict) for j in range(len(all_factors)) if j not in combo]
         )
+        print(valid_set)
 
         # Determine whether it's possible for the critical point vanish in this
         # combination of factors
@@ -819,7 +820,10 @@ def compute_asymptotic_contribution(
             except:
                 valid_set = None
 
-        # Step 2: Find the locally parametrizing coordinates of the point pt
+        # Check conditions needed for point to be contributing
+        # Might just need for point to be non-critical in upper dimensional component?
+
+        # Find the locally parametrizing coordinates of the point pt
         # Since we have d variables and s factors, there should be d-s of these
         # parametrizing coordinates
         # We will try to parametrize with the first d-s coordinates, shuffling
@@ -834,10 +838,7 @@ def compute_asymptotic_contribution(
             if Jac.determinant() != 0:
                 break
 
-            try:
-                valid_set = valid_set.setminus([Jac.determinant()])
-            except:
-                valid_set = None
+            valid_set = valid_set.setminus([Jac.determinant()])
 
             acsv_logger.info("Variables do not parametrize, shuffling")
             vs_r_cp = list(zip(vs, r, cp))
@@ -846,6 +847,9 @@ def compute_asymptotic_contribution(
         else:
             raise ACSVException("Cannot find parametrizing set.")
 
+        if valid_set.is_empty():
+            continue
+
         expansion, constant_squared, base, exponent, s = _compute_asm_quantity(
             G, H, vs, cp, r, subs_dict, unit,factors, multiplicities, 1
         )

sage_acsv/helpers.py

@@ -572,7 +572,7 @@ def get_expansion_terms(
 
 class Restriction():
     def __init__(self, base_ring):
-        if len(base_ring.gens()) == 0:
+        if base_ring == SR or len(base_ring.gens()) == 0:
             self.base_ring = SR
             self.base_field = SR
             self.inclusion = []
@@ -592,6 +592,7 @@ def intersection(self, eqns):
                 Id = compute_radical(Ideal([self.base_ring.zero()] + [self.base_ring(f * prod(denoms)) for f in eqns]))
                 self.inclusion += Id
             except:
+                print(1)
                 self.inclusion = eqns + [SR(f) for f in self.inclusion.gens()]
                 self.exclusion = [SR(f) for f in self.exclusion.gens()]
                 self.base_ring = SR
@@ -602,13 +603,16 @@ def intersection(self, eqns):
         return self
 
     def setminus(self, eqns):
+        if not eqns:
+            return
         if self.base_ring != SR:
             try:
                 eqns = [self.base_field(f) for f in eqns]
                 denoms = [f.denominator() for f in eqns]
-                Id = compute_radical(Ideal([self.base_ring.zero()] + [self.base_ring(f * prod(denoms)) for f in eqns]))
+                Id = compute_radical(Ideal([self.base_ring(f * prod(denoms)) for f in eqns]))
                 self.exclusion = self.exclusion.intersection(Id)
             except:
+                print(2)
                 self.inclusion = [SR(f) for f in self.inclusion.gens()]
                 self.exclusion = eqns + [SR(f) for f in self.exclusion.gens()]
                 self.base_ring = SR
@@ -643,7 +647,24 @@ def contains(self, other : Restriction):
         return True
 
     def is_empty(self):
-        return self.contains(Restriction(self.base_ring).intersection([1]))
+        self.simplify()
+        inclusion_gens = self.inclusion if self.base_field == SR else self.inclusion.gens()
+        exclusion_gens = self.exclusion if self.base_field == SR else self.exclusion.gens()
+        for val in inclusion_gens:
+            try:
+                val = QQbar(val)
+                if val != 0:
+                    return True
+            except:
+                pass
+        for val in exclusion_gens:
+            try:
+                val = QQbar(val)
+                if val == 0:
+                    return True
+            except:
+                pass
+        return False
 
     def __str__(self):
         return f"Quasi-Affine variety defined by X - Y where X is \n {self.inclusion} and Y is \n {self.exclusion}"