shimura_curves: accept starred names in the jump box, add route tests

The jump box split its input on "*" before trying to recognize it, so
starred curve names like X*(6;1) could never be found, and the canonical
spelling X^*(6;1) was not accepted by NAME_RE at all.  Now:

- the whole input is first tried as a single label or standard name, and
  only then is "*" treated as a fiber product separator (splitting only
  at asterisks not followed by "(", so starred factors survive);
- NAME_RE and shimcurve_lmfdb_label accept both X*(D;N) and X^*(D;N)
  (plus lowercase x), canonicalized via canonicalize_name to the X^*(D;N)
  form stored in the name column;
- the fiber product branch no longer queries the nonexistent
  factorization column of gps_shimura_test (which raised a ValueError);
  the modular-curve X(1) special case is replaced by its analogue here,
  dropping index-1 factors with the same ambient (discB, discO, level,
  deg_mu), so e.g. X(6;1)*X^*(6;1) resolves to X(6;1), and unresolvable
  or malformed products flash a clean error instead of a 500.

Add route-level tests for label/name/starred-name jumps, resolving and
failing fiber products, malformed input, the search page, the starred
family search, and individual curve pages, with content checked against
gps_shimura_test.

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

Author: roed314

lmfdb/shimura_curves/main.py

@@ -59,7 +59,10 @@
 fine_label_re = r"\d+\.\d+\.(?:\d+\.)?\d+\.\d+\.\d+-\d+\.\d+\.[a-z]+\.\d+\.\d+"
 LABEL_RE = re.compile(f"({coarse_label_re})|({fine_label_re})")
 FINE_LABEL_RE = re.compile(fine_label_re)
-NAME_RE = re.compile(r"X\*?\(\d+(,\d+)?(;|,)\d+\)")
+# Accepts the standard names X(D;N), X(D,M;N) and the starred (Atkin-Lehner
+# quotient) names in both spellings X*(D;N) and X^*(D;N); canonicalize_name
+# turns all of them into the form stored in the database.
+NAME_RE = re.compile(r"X(\^?\*)?\(\d+(,\d+)?(;|,)\d+\)")
 
 def learnmore_list():
     return [('Source and acknowledgments', url_for(".how_computed_page")),
@@ -234,46 +237,81 @@ def shimcurve_lmfdb_label(label):
         lmfdb_label = label
     elif NAME_RE.fullmatch(label.upper()):
         label_type = "name"
-        lmfdb_label = db.gps_shimura_test.lucky({"name": canonicalize_name(label)}, "label")
+        # canonicalize_name maps both starred spellings X*(D;N) and X^*(D;N)
+        # to the canonical form X^*(D;N) used in the name column
+        lmfdb_label = db.gps_shimura_test.lucky({"name": canonicalize_name(label.upper())}, "label")
     else:
         label_type = "label"
         lmfdb_label = None
     return lmfdb_label, label_type
 
 def shimcurve_jump(info):
-    labels = (info["jump"]).split("*")
+    jump = info["jump"].strip()
+    # Starred names such as X*(6;1) or X^*(6;1) contain an asterisk that is
+    # part of the name, so we first try to interpret the whole input as a
+    # single label or name before treating * as a fiber product separator.
+    lmfdb_label, label_type = shimcurve_lmfdb_label(jump)
+    if lmfdb_label is not None:
+        return redirect(url_for_shimcurve_label(lmfdb_label))
+    if label_type == "name":
+        # A syntactically valid name (possibly starred) that is not in the
+        # database; the asterisk is not a fiber product separator here.
+        flash_error("There is no Shimura curve in the database with name %s", jump)
+        return redirect(url_for(".index"))
+    # Now interpret * as a fiber product separator.  An asterisk that is part
+    # of a starred name is always followed by an open parenthesis, so we only
+    # split at asterisks that are not.
+    labels = [piece.strip() for piece in re.split(r"\*(?!\()", jump)]
+    labels = [piece for piece in labels if piece]
+    if len(labels) <= 1:
+        flash_error("There is no Shimura curve in the database with %s %s", label_type, jump)
+        return redirect(url_for(".index"))
     lmfdb_labels = []
     for label in labels:
         lmfdb_label, label_type = shimcurve_lmfdb_label(label)
         if lmfdb_label is None:
             flash_error("There is no Shimura curve in the database with %s %s", label_type, label)
             return redirect(url_for(".index"))
         lmfdb_labels.append(lmfdb_label)
-    lmfdb_labels_not_X1 = [l for l in lmfdb_labels if l != "1.1.0.a.1"]
-    if len(lmfdb_labels) == 1:
-        label = lmfdb_labels[0]
-        return redirect(url_for_shimcurve_label(label))
-    elif len(lmfdb_labels_not_X1) == 1:
-        label = lmfdb_labels_not_X1[0]
-        return redirect(url_for_shimcurve_label(label))
-    else:
+    # Check that all the factors exist and get the data needed below
+    curvedata = {rec["label"]: rec for rec in db.gps_shimura_test.search(
+        {"label": {"$in": lmfdb_labels}},
+        ["label", "index", "discB", "discO", "level", "deg_mu"])}
+    for label in lmfdb_labels:
+        if label not in curvedata:
+            flash_error("There is no Shimura curve in the database with label %s", label)
+            return redirect(url_for(".index"))
+
+    def ambient(label):
+        rec = curvedata[label]
+        return (rec["discB"], rec["discO"], rec["level"], rec["deg_mu"])
+    # Analogue of X(1) in the modular curve jump: a factor of index 1
+    # corresponds to the full ambient group, so it is the base of the fiber
+    # product and the fiber product with it changes nothing (as long as it has
+    # the same ambient data as the other factor).
+    nontrivial = [l for l in lmfdb_labels if curvedata[l]["index"] != 1]
+    if len(nontrivial) == 1:
+        label = nontrivial[0]
+        if all(ambient(l) == ambient(label) for l in lmfdb_labels):
+            return redirect(url_for_shimcurve_label(label))
+    # Check labels are indeed distinct
+    if len(set(nontrivial)) != len(nontrivial):
+        flash_error("Fiber product decompositions cannot contain repeated terms")
+        return redirect(url_for(".index"))
+    label = None
+    if nontrivial and "factorization" in db.gps_shimura_test.search_cols:
         # Get factorization for each label
-        factors = list(db.gps_shimura_test.search({"label": {"$in": lmfdb_labels_not_X1}},
-                                                  ["label","factorization"]))
+        factors = list(db.gps_shimura_test.search({"label": {"$in": nontrivial}},
+                                                  ["label", "factorization"]))
         factors = [(f["factorization"] if f["factorization"] != [] else [f["label"]])
                    for f in factors]
-        # Check labels are indeed distinct
-        if len(factors) != len(lmfdb_labels_not_X1):
-            flash_error("Fiber product decompositions cannot contain repeated terms")
-            return redirect(url_for(".index"))
         # Get list of all factors, lexicographically sorted
         factors = sorted(sum(factors, []), key=key_for_numerically_sort)
         label = db.gps_shimura_test.lucky({'factorization': factors}, "label")
-        if label is None:
-            flash_error("There is no Shimura curve in the database isomorphic to the fiber product %s", info["jump"])
-            return redirect(url_for(".index"))
-        else:
-            return redirect(url_for_shimcurve_label(label))
+    if label is None:
+        flash_error("There is no Shimura curve in the database isomorphic to the fiber product %s", jump)
+        return redirect(url_for(".index"))
+    return redirect(url_for_shimcurve_label(label))
 
 def blankzeros(n):
     return "$%o$"%n if n else ""

lmfdb/shimura_curves/test_shimura_curves.py

@@ -1,12 +1,138 @@
 # -*- coding: utf-8 -*-
 
+from urllib.parse import quote
+
 from lmfdb.tests import LmfdbTest
 
+# These are checked against the database in the tests below
+STAR_NAME = "X^*(6;1)"  # canonical spelling of the starred curve name
+STAR_LABEL = "6.1.1.1.0.a.1"
+PLAIN_NAME = "X(6;1)"
+PLAIN_LABEL = "6.1.1.4.0.a.1"
+
+
 class ShimCrvTest(LmfdbTest):
+    def jump(self, entry):
+        return self.tc.get(
+            "/ShimuraCurve/Q/?jump=%s" % quote(entry, safe=""),
+            follow_redirects=True,
+        )
+
     def test_home(self):
         L = self.tc.get('/ShimuraCurve/Q/')
         assert 'Shimura curves' in L.get_data(as_text=True)
         assert 'Browse' in L.get_data(as_text=True)
         assert 'Search' in L.get_data(as_text=True)
         assert 'Find' in L.get_data(as_text=True)
         assert 'X(D;N)' in L.get_data(as_text=True)
+
+    def test_jump_label(self):
+        # Jumping to an LMFDB label goes directly to the curve page
+        rec = self.db.gps_shimura_test.lookup(STAR_LABEL, ["name", "label"])
+        assert rec["name"] == STAR_NAME
+        L = self.jump(STAR_LABEL)
+        assert L.status_code == 200
+        page = L.get_data(as_text=True)
+        assert STAR_LABEL in page
+        assert STAR_NAME in page
+
+    def test_jump_plain_name(self):
+        # An unstarred standard name, in both X(D;N) and X(D,N) spellings
+        assert self.db.gps_shimura_test.lucky({"name": PLAIN_NAME}, "label") == PLAIN_LABEL
+        for entry in [PLAIN_NAME, "X(6,1)"]:
+            L = self.jump(entry)
+            assert L.status_code == 200
+            page = L.get_data(as_text=True)
+            assert PLAIN_LABEL in page
+            assert PLAIN_NAME in page
+
+    def test_jump_starred_name(self):
+        # Starred names contain an asterisk, which must not be treated as a
+        # fiber product separator; both X*(D;N) and the canonical X^*(D;N)
+        # spelling are accepted (as well as a lowercase x)
+        assert self.db.gps_shimura_test.lucky({"name": STAR_NAME}, "label") == STAR_LABEL
+        for entry in ["X*(6;1)", "X^*(6;1)", "x*(6;1)"]:
+            L = self.jump(entry)
+            assert L.status_code == 200
+            page = L.get_data(as_text=True)
+            assert STAR_LABEL in page, entry
+            assert STAR_NAME in page, entry
+
+    def test_jump_fiber_product(self):
+        # X^*(6;1) has index 1 (its group is the full ambient group), so the
+        # fiber product of X(6;1) with it is X(6;1) itself; this can be
+        # entered with names (including starred ones) or labels
+        for entry in [
+                "X(6;1)*X^*(6;1)",
+                "X*(6;1)*X(6;1)",
+                "%s*%s" % (PLAIN_LABEL, STAR_LABEL),
+        ]:
+            L = self.jump(entry)
+            assert L.status_code == 200
+            page = L.get_data(as_text=True)
+            assert PLAIN_LABEL in page, entry
+            assert PLAIN_NAME in page, entry
+        # A fiber product not isomorphic to any curve in the database
+        # produces a clean error message
+        assert self.db.gps_shimura_test.lucky({"name": "X(10;1)"}, "label") is not None
+        L = self.jump("X(6;1)*X(10;1)")
+        assert L.status_code == 200
+        assert "There is no Shimura curve in the database isomorphic to the fiber product" in L.get_data(as_text=True)
+        # Repeated factors are rejected with a clean error message
+        L = self.jump("X(6;1)*X(6;1)")
+        assert L.status_code == 200
+        assert "Fiber product decompositions cannot contain repeated terms" in L.get_data(as_text=True)
+
+    def test_jump_malformed(self):
+        # Malformed input (including malformed starred names) should flash an
+        # error, not produce a 500
+        for entry in ["X*(6;", "X^*(6;", "X*(6;1", "banana", "X(6;1)*banana"]:
+            L = self.jump(entry)
+            assert L.status_code == 200, entry
+            assert "There is no Shimura curve in the database" in L.get_data(as_text=True), entry
+        # A syntactically valid starred name that is not in the database
+        L = self.jump("X*(10;1)")
+        assert L.status_code == 200
+        assert "There is no Shimura curve in the database with name" in L.get_data(as_text=True)
+
+    def test_search(self):
+        # All discB = 6, level 1 curves should show up in a search
+        expected = sorted(rec["label"] for rec in self.db.gps_shimura_test.search(
+            {"discB": 6, "level": 1}, ["label"]))
+        assert PLAIN_LABEL in expected and STAR_LABEL in expected
+        L = self.tc.get("/ShimuraCurve/Q/?discB=6&level=1")
+        assert L.status_code == 200
+        page = L.get_data(as_text=True)
+        for label in expected:
+            assert label in page
+        # names are displayed (in LaTeX form) in the search results
+        assert STAR_NAME in page
+        assert PLAIN_NAME in page
+
+    def test_search_family(self):
+        # Searching for the starred family X^*(D;N) should find the starred curve
+        starred = sorted(rec["label"] for rec in self.db.gps_shimura_test.search(
+            {"name": {"$like": "X^*(%"}}, ["label"]))
+        assert STAR_LABEL in starred
+        L = self.tc.get("/ShimuraCurve/Q/?family=XDNstar")
+        assert L.status_code == 200
+        page = L.get_data(as_text=True)
+        for label in starred:
+            assert label in page
+
+    def test_curve_page(self):
+        # Check content of individual curve pages against the database
+        for label in [PLAIN_LABEL, STAR_LABEL]:
+            rec = self.db.gps_shimura_test.lookup(
+                label, ["name", "genus", "index", "discB", "level"])
+            L = self.tc.get("/ShimuraCurve/Q/%s/" % label)
+            assert L.status_code == 200
+            page = L.get_data(as_text=True)
+            assert "Shimura curve $%s$" % rec["name"] in page
+            assert label in page
+            # invariants from the database: genus (as displayed by show_genus),
+            # index and discriminant
+            assert "$ %s " % rec["genus"] in page
+            assert "$%s$" % rec["index"] in page
+            assert "Discriminant of $B$" in page
+            assert "$%s$" % rec["discB"] in page