Mention ramified prime count in number field completeness message (LMFDB#7020)

The completeness bounds in NFBound.clear_S keyed on num_ram (_nSp, _nSGp)
were displayed as if completeness held for all fields unramified outside S,
omitting the essential bound on the number of ramified primes.  Extend the
reason tuples with an nram slot (recorded only when nram < len(S), so all
other messages are unchanged) and display it as 'at most k ramified
prime(s)'.

Verified against devmirror: the query from the issue now reports 'number
fields with degree 5, unramified outside {2,3,5,7,11,13}, at most 1
ramified prime', the same search without num_ram remains incomplete, and
lmfdb/tests/test_utils.py (including a new regression pair) passes.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: roed314

lmfdb/tests/test_utils.py

@@ -342,6 +342,7 @@ def test_complete(self):
                 ("nf_fields", {'degree': 5, 'galois_label': '5T4', 'disc_abs': 920627786839041}, "number fields with degree 5, Galois group 5T(1,2,4), unramified outside {3,1201}"),
                 ("nf_fields", {'degree': 5, 'galois_label': '5T4', 'gal_is_abelian': True, 'disc_abs': 920627786839041}, "number fields with incompatible conditions: Galois group"),
                 ("nf_fields", {'degree': 5, 'galois_label': '5T4', 'disc_rad': 1254}, "number fields with degree 5, Galois group 5T(1,2,4), unramified outside {2,3,11,19}"),
+                ("nf_fields", {'degree': 5, 'num_ram': 1, 'ramps': {'$containedin': [2, 3, 5, 7, 11, 13]}}, "number fields with degree 5, unramified outside {2,3,5,7,11,13}, at most 1 ramified prime"),
                 ("nf_fields", {'degree': 8, 'galois_label': '8T25', 'rd': {'$gte': 1, '$lte': 100}}, "number fields with degree 8, Galois group 8T(25,36), Galois root discriminant at most 200"),
                 ("nf_fields", {'degree': 2, 'r2': 0, 'regulator': {'$gte': 0, '$lte': 7}}, "number fields with degree 2, signature [2,0], regulator less than 7.25"),
                 ("nf_fields", {'degree': 2, 'r2': 1, 'regulator': {'$gte': 0, '$lte': 0.999}}, "number fields with degree 2, signature [0,1], regulator less than 1.00"),
@@ -394,6 +395,7 @@ def test_complete(self):
                 ("bmf_forms", {'field_disc': {'$gte': -120, '$lte': -3}, 'level_norm': {'$gte': 1, '$lte': 4000}}),
                 ("ec_nfcurves", {'field_label': '7.7.20134393.1', 'conductor_norm': {'$gte': 1, '$lte': 50}}),
                 ("nf_fields", {'degree': 6, 'disc_abs': {'$gte': 1, '$lte': 20000000}}),
+                ("nf_fields", {'degree': 5, 'ramps': {'$containedin': [2, 3, 5, 7, 11, 13]}}),
                 ("nf_fields", {'degree': 2, 'r2': 1, 'regulator': 1}),
                 ("nf_fields", {'degree': 4, 'r2': 2, 'regulator': {'$gte': 0.962, '$lte': 0.963}}),   # Infinitely many degree 4 CM fields with regulator 0.962423650119
                 ("nf_fields", {'degree': 6, 'r2': 3, 'regulator': {'$gte': 2.101, '$lte': 2.102}}),   # Infinitely many degree 6 CM fields with regulator 2.10181872849

lmfdb/utils/completeness.py

@@ -1991,16 +1991,18 @@ def display_reason(self, reasons):
         INPUT:
 
         - ``reasons`` -- a set of reasons, which are either a string or
-          a tuple of the form ``(n, r2, galt, ramps, D_bound, grd_bound, reg)``,
+          a tuple of the form ``(n, r2, galt, ramps, nram, D_bound, grd_bound, reg)``,
           where entries are None if they are not applicable.
         """
         # Current tuples created:
-        # (n, r2, None, None, M, None, None)
-        # (n, r2, Gs, None, M, None, None)
-        # (n, None, Gs, None, None, M, None)
-        # (n, None, None, S, None, None, None)
-        # (n, None, Gs, S, None, None, None)
-        # (n, r2, None, None, None, None, R)
+        # (n, r2, None, None, None, M, None, None)
+        # (n, r2, Gs, None, None, M, None, None)
+        # (n, None, Gs, None, None, None, M, None)
+        # (n, None, None, S, k, None, None, None)
+        # (n, None, Gs, S, k, None, None, None)
+        # (n, r2, None, None, None, None, None, R)
+        # Here k (a bound on the number of ramified primes) is None unless
+        # completeness depends on it (i.e. unless k < len(S)).
         # We group by None pattern
         def describe(tups):
             ans = []
@@ -2030,19 +2032,26 @@ def describe(tups):
                 else:
                     ans.append(f"unramified outside {','.join()}")
             if tups[0][4] is not None:
-                Dbounds = [str(tup[4]) for tup in tups]
+                nrams = [str(tup[4]) for tup in tups]
+                if len(set(nrams)) == 1:
+                    plural = "" if tups[0][4] == 1 else "s"
+                    ans.append(f"at most {nrams[0]} ramified prime{plural}")
+                else:
+                    ans.append(f"at most {','.join(nrams)} ramified primes")
+            if tups[0][5] is not None:
+                Dbounds = [str(tup[5]) for tup in tups]
                 if len(set(Dbounds)) == 1:
                     ans.append(f"absolute discriminant at most {Dbounds[0]}")
                 else:
                     ans.append(f"absolute discriminant at most {','.join(Dbounds)}")
-            if tups[0][5] is not None:
-                grd = [str(tup[5]) for tup in tups]
+            if tups[0][6] is not None:
+                grd = [str(tup[6]) for tup in tups]
                 if len(set(grd)) == 1:
                     ans.append(f"Galois root discriminant at most {grd[0]}")
                 else:
                     ans.append(f"Galois root discriminant at most {','.join(grd)}")
-            if tups[0][6] is not None:
-                reg_bounds = [RR(tup[6]) for tup in tups]
+            if tups[0][7] is not None:
+                reg_bounds = [RR(tup[7]) for tup in tups]
                 if len(set(reg_bounds)) == 1:
                     ans.append(f"regulator less than {float(reg_bounds[0]):.2f}")
                 else:
@@ -2058,7 +2067,7 @@ def describe(tups):
                 if not reason.startswith("incompatible conditions"):
                     non_incomp.append(reason)
             else:
-                by_pattern[tuple(i for i in range(7) if reason[i] is None)].append(reason)
+                by_pattern[tuple(i for i in range(8) if reason[i] is None)].append(reason)
         if len(non_incomp) + len(by_pattern) > 0:
             strings = non_incomp
         return "number fields with " + "; ".join(strings + [describe(V) for V in by_pattern.values()])
@@ -2074,7 +2083,7 @@ def clear_signatures(self, n, D, r2opts, reasons):
                 M = self._maxD[n][r2]
                 if D.bounded(M):
                     r2opts.remove(r2)
-                    reasons.add((n, r2, None, None, M, None, None))
+                    reasons.add((n, r2, None, None, None, M, None, None))
                 m = min(m, M)
             if m is not infinity:
                 D = D.intersection(bottom(m + 1))
@@ -2096,7 +2105,7 @@ def clear_regulator(self, n, R, r2opts, reasons):
                 M = maxReg - 0.00001  # Completeness only guaranteed if R *strictly less* than M
                 if R.bounded(M):
                     r2opts.remove(r2)
-                    reasons.add((n, r2, None, None, None, None, maxReg))
+                    reasons.add((n, r2, None, None, None, None, None, maxReg))
                 m = min(m, M)
             if m is not infinity:
                 R = R.intersection(bottom(m))
@@ -2115,7 +2124,7 @@ def clear_r2G(self, n, D, r2opts, galt, reasons):
             if set(r2G[t]) == set(r2opts):
                 galt.remove(t)
                 for r2, Gs, M in r2G[t].values():
-                    reasons.add((n, r2, Gs, None, M, None, None))
+                    reasons.add((n, r2, Gs, None, None, M, None, None))
 
     def clear_grd(self, n, grd, galt, reasons):
         """
@@ -2129,7 +2138,7 @@ def clear_grd(self, n, grd, galt, reasons):
         for t in galt.intersection(by_t):
             galt.remove(t)
             Gs, M = by_t[t]
-            reasons.add((n, None, Gs, None, None, M, None))
+            reasons.add((n, None, Gs, None, None, None, M, None))
 
     def clear_S(self, n, S, nram, galt, reasons, update_galt=True):
         """
@@ -2139,14 +2148,18 @@ def clear_S(self, n, S, nram, galt, reasons, update_galt=True):
             galt = set(galt)
         if nram is None:
             nram = len(S)
+        # The completeness bounds keyed on nram below only apply because the number of
+        # ramified primes is bounded; when nram < len(S) this constraint does not follow
+        # from being unramified outside S, so we record it for display in the message.
+        shown_nram = nram if nram < len(S) else None
 
         if S in self._nS.get(n, {}):
-            reasons.add((n, None, None, S, None, None, None))
+            reasons.add((n, None, None, S, None, None, None, None))
             return True
 
         M = self._nSp.get(n, {}).get(nram)
         if M is not None and all(p < M for p in S):
-            reasons.add((n, None, None, S, None, None, None))
+            reasons.add((n, None, None, S, shown_nram, None, None, None))
             return True
 
         if galt is None:
@@ -2156,7 +2169,7 @@ def clear_S(self, n, S, nram, galt, reasons, update_galt=True):
             if all(p < M for p in S):
                 I = galt.intersection(Gs)
                 if I:
-                    reasons.add((n, None, Gs, S, None, None, None))
+                    reasons.add((n, None, Gs, S, shown_nram, None, None, None))
                     galt.difference_update(I)
                     if not galt:
                         return True
@@ -2166,7 +2179,7 @@ def clear_S(self, n, S, nram, galt, reasons, update_galt=True):
                 if min(S) == p0 and max(S) < M:
                     I = galt.intersection(Gs)
                     if I:
-                        reasons.add((n, None, Gs, S, None, None, None))
+                        reasons.add((n, None, Gs, S, None, None, None, None))
                         galt.difference_update(I)
                         if not galt:
                             return True
@@ -2176,7 +2189,7 @@ def clear_S(self, n, S, nram, galt, reasons, update_galt=True):
             if SS.issubset(T):
                 I = galt.intersection(Gs)
                 if I:
-                    reasons.add((n, None, Gs, S, None, None, None))
+                    reasons.add((n, None, Gs, S, None, None, None, None))
                     galt.difference_update(I)
                     if not galt:
                         return True
@@ -2504,7 +2517,7 @@ def __call__(self, db, query):
 
         # We collect reasons that have contributed to completeness
         # These have the following format:
-        # (n, r2, galt, ramps, D_bound, grd_bound, Reg)
+        # (n, r2, galt, ramps, nram, D_bound, grd_bound, Reg)
         # Where entries can be None if they are not applicable
         reasons = set()
         # First check completeness without splitting on degree