Only highlight a select once it constrains the results

A select beside a text box usually says how to read that box, and is
handed to a @search_parser function as its mode.  Those return
immediately when their field is empty, so such a select cannot affect
the query on its own; TextBoxWithSelect now treats its select as
constraining only once the text box it qualifies has been filled in.

Six selects are read directly while parsing instead, and so do restrict
the results by themselves: the level type in classical modular forms and
modular curves, the conductor type in elliptic curves and mod-l Galois
representations, and the two CMF parities, which usually arrive with
their text boxes empty because simult_change() submits both at once.
Those pass is_constraint=True.  Modular curves matters in particular
because modcurve_browse.html links straight to ?level_type=... searches.

The hypergeometric prime and the abelian variety geometric-decomposition
checkbox are the same shape: both only pick which column a partner box is
matched against, so they are gated on those boxes rather than highlighted
whenever set.

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

Author: roed314

lmfdb/abvar/fq/main.py

@@ -162,6 +162,23 @@ def AV_data(label):
     return datapage(labels, tables, title=f"Abelian variety isogeny class data - {label}", bread=bread, label_cols=label_cols, sorts=sorts)
 
 
+# The inputs whose database column the "Use geometric decomposition"
+# checkbox switches; see common_parse
+GEOM_DECOMP_INPUTS = (["dim%s_factors" % n for n in range(1, 6)]
+                      + ["dim%s_distinct" % n for n in range(1, 4)]
+                      + ["number_field", "galois_group"])
+
+def use_geom_decomp_is_constraint(info):
+    """
+    Whether the "Use geometric decomposition" checkbox is restricting which
+    results are shown.
+
+    It only chooses which columns the dimension, number field and Galois
+    group inputs are matched against, so with all of those empty it changes
+    neither the results nor how they are displayed.
+    """
+    return any((info.get(name) or '').strip() for name in GEOM_DECOMP_INPUTS)
+
 class AbvarSearchArray(SearchArray):
     sorts = [("", "dimension", ['g', 'q', 'poly']),
              ("q", "field", ['q', 'g', 'poly']),
@@ -426,7 +443,8 @@ def nbsp(knowl, label):
         use_geom_decomp = CheckBox(
             "use_geom_decomp",
             label=uglabel,
-            short_label=uglabel
+            short_label=uglabel,
+            is_constraint=use_geom_decomp_is_constraint
         )
         use_geom_index = CheckboxSpacer(use_geom_decomp, colspan=4, advanced=True)
         use_geom_refine = CheckboxSpacer(use_geom_decomp, colspan=5, advanced=True)

lmfdb/abvar/fq/test_av.py

@@ -3,6 +3,17 @@
 
 class AVTest(LmfdbTest):
     # All tests should pass
+    def test_geom_decomp_active_classes(self):
+        r"""
+        Check that the geometric decomposition checkbox is only marked as
+        constraining the results once one of the inputs it re-targets is used
+        """
+        url = "/Variety/Abelian/Fq/?q=2&g=2&use_geom_decomp=yes&search_type=List"
+        self.assertEqual(self.search_classes(url, "use_geom_decomp"), set())
+        url += "&dim1_factors=1"
+        self.assertEqual(self.search_classes(url, "use_geom_decomp"),
+                         {"search_constraint", "search_active"})
+
     def test_polynomial(self):
         r"""
         Check that the formatted polynomial displays correctly

lmfdb/classical_modular_forms/main.py

@@ -1582,6 +1582,9 @@ class CMFSearchArray(SearchArray):
     }
 
     def __init__(self):
+        # Unlike most quantifier selects, this one restricts the results on
+        # its own: common_parse turns prime/square/squarefree/... into a
+        # level_is_* condition whether or not a level was entered
         level_quantifier = SelectBox(
             name='level_type',
             options=[('', ''),
@@ -1594,7 +1597,8 @@ def __init__(self):
                      ('divides','divides'),
                      ('multiple','multiple of'),
                      ],
-            min_width=110)
+            min_width=110,
+            is_constraint=True)
         level = TextBoxWithSelect(
             name='level',
             label='Level',
@@ -1603,10 +1607,14 @@ def __init__(self):
             example_span='4, 1-20',
             select_box=level_quantifier)
 
+        # The parities also restrict the results on their own, and in fact
+        # usually arrive that way: simult_change() sets every simult_select
+        # at once, so both are submitted even with the text boxes empty
         weight_quantifier = ParityMod(
             name='weight_parity',
             classes=["simult_select"],
-            extra=['onchange="simult_change(event);"'])
+            extra=['onchange="simult_change(event);"'],
+            is_constraint=True)
 
         weight = TextBoxWithSelect(
             name='weight',
@@ -1619,7 +1627,8 @@ def __init__(self):
         character_quantifier = ParityMod(
             name='char_parity',
             classes=["simult_select"],
-            extra=['onchange="simult_change(event);"'])
+            extra=['onchange="simult_change(event);"'],
+            is_constraint=True)
 
         character = TextBoxWithSelect(
             name='char_label',

lmfdb/classical_modular_forms/test_cmf2.py

@@ -214,6 +214,24 @@ def test_simult_select_classes(self):
             self.assertEqual(self.search_classes(url, name),
                              {'simult_select', 'search_constraint'})
 
+    def test_quantifier_active_classes(self):
+        # A quantifier select is handed to a parser that does nothing when
+        # its text box is empty, so it is only active once that box is filled
+        url = '/ModularForm/GL2/Q/holomorphic/?level=11'
+        self.assertEqual(self.search_classes(url, 'prime_quantifier'), set())
+        url = ('/ModularForm/GL2/Q/holomorphic/?level=11&level_primes=11'
+               '&prime_quantifier=exactly')
+        self.assertEqual(self.search_classes(url, 'prime_quantifier'),
+                         {'search_constraint', 'search_active'})
+
+        # The parities and the level type are the exceptions: common_parse
+        # reads them whether or not their text box was filled in, so they do
+        # constrain the results on their own and must stay highlighted
+        url = '/ModularForm/GL2/Q/holomorphic/?level=11-20&weight_parity=odd'
+        self.assertEqual(self.search_classes(url, 'weight_parity'),
+                         {'simult_select', 'search_constraint', 'search_active'})
+        self.assertEqual(self.search_classes(url, 'weight'), {'search_constraint'})
+
     def test_trivial_searches(self):
         from sage.all import Subsets
         for begin in [

lmfdb/elliptic_curves/elliptic_curve.py

@@ -1291,6 +1291,9 @@ class ECSearchArray(SearchArray):
                                }
 
     def __init__(self):
+        # Unlike most quantifier selects, this one restricts the results on
+        # its own: prime/p-power/sq-free set num_bad_primes and semistable
+        # whether or not a conductor was entered
         conductor_quantifier = SelectBox(
             name='conductor_type',
             options=[('', ''),
@@ -1300,7 +1303,8 @@ def __init__(self):
                      ('divides','divides'),
                      ('multiple','multiple of'),
                      ],
-            min_width=85)
+            min_width=85,
+            is_constraint=True)
         cond = TextBoxWithSelect(
             name="conductor",
             label="Conductor",

lmfdb/hypergm/main.py

@@ -712,6 +712,17 @@ def labels_page():
            learnmore=learnmore_list_remove('labels'))
 
 
+def p_is_constraint(info):
+    """
+    Whether the prime $p$ input is restricting which results are shown.
+
+    The prime only picks which columns the $A_p$, $B_p$, $A^\\perp_p$ and
+    $B^\\perp_p$ boxes are compared against, so with all four of those empty
+    it changes neither the results nor how they are displayed.
+    """
+    return any((info.get(name) or '').strip()
+               for name in ['Ap', 'Bp', 'Apperp', 'Bpperp'])
+
 class HGMSearchArray(SearchArray):
     _sort = [('', 'degree', ['degree', 'weight', 'A', 'B', 'label']),
             ('weight', 'weight', ['weight', 'degree', 'A', 'B', 'label']),
@@ -764,7 +775,8 @@ def __init__(self):
             options=[("", 2),
                      ("3", 3),
                      ("5", 5),
-                     ("7", 7)])
+                     ("7", 7)],
+            is_constraint=p_is_constraint)
         Ap = TextBox(
             name="Ap",
             label="$A_p$",

lmfdb/hypergm/test_hgm.py

@@ -73,6 +73,15 @@ def test_search_active_classes(self):
         self.assertEqual(self.search_classes(url, "weight"),
                          {"family", "search_constraint"})
 
+    def test_prime_active_classes(self):
+        # The prime only picks the columns the p-part boxes are compared
+        # against, so on its own it does not constrain the results
+        url = "/Motive/Hypergeometric/Q/?degree=4&p=3&search_type=Family"
+        self.assertEqual(self.search_classes(url, "p"), set())
+        url += "&Ap=%5B2%2C1%5D"
+        self.assertEqual(self.search_classes(url, "p"),
+                         {"search_constraint", "search_active"})
+
     def test_search_weight(self):
         self.check_args("/Motive/Hypergeometric/Q/?weight=3&search_type=Family", "A5_B6.6")
         self.not_check_args("/Motive/Hypergeometric/Q/?weight=3&search_type=Family", "A3_B4")

lmfdb/modl_galois_representations/main.py

@@ -227,6 +227,9 @@ class ModLGalRepSearchArray(SearchArray):
     jump_knowl = "modlgal.search_input"
 
     def __init__(self):
+        # Unlike most quantifier selects, this one restricts the results on
+        # its own: prime/p-power/sq-free set conductor_num_primes and
+        # conductor_is_squarefree whether or not a conductor was entered
         conductor_quantifier = SelectBox(
             name='conductor_type',
             options=[('', ''),
@@ -236,6 +239,7 @@ def __init__(self):
                      ('divides','divides'),
                      ('multiple','multiple of'),
                      ],
+            is_constraint=True,
             )
         conductor = TextBoxWithSelect(
             name="conductor",

lmfdb/modular_curves/main.py

@@ -767,6 +767,10 @@ class ModCurveSearchArray(SearchArray):
     jump_knowl = "modcurve.search_input"
 
     def __init__(self):
+        # Unlike most quantifier selects, this one restricts the results on
+        # its own: prime/p-power/sq-free set num_bad_primes and
+        # level_is_squarefree whether or not a level was entered, and
+        # modcurve_browse.html links straight to ?level_type=... searches
         level_quantifier = SelectBox(
             name="level_type",
             options=[('', ''),
@@ -776,7 +780,8 @@ def __init__(self):
                      ('divides', 'divides'),
                      ('multiple', 'multiple of'),
                      ],
-            min_width=85)
+            min_width=85,
+            is_constraint=True)
         level = TextBoxWithSelect(
             name="level",
             knowl="modcurve.level",

lmfdb/modular_curves/test_modular_curves.py

@@ -34,6 +34,18 @@ def test_level_search(self):
         L = self.tc.get("/ModularCurve/Q/?start=0&level_type=divides&level=15")
         assert "15.12.0.b.2" in L.get_data(as_text=True)
 
+    def test_level_type_active_classes(self):
+        # modcurve_browse.html links straight to ?level_type=... searches, so
+        # the level type has to stay marked as constraining the results even
+        # with no level entered, unlike the quantifier selects that only say
+        # how to read the box beside them
+        self.assertEqual(self.search_classes("/ModularCurve/Q/?level_type=prime",
+                                             "level_type"),
+                         {"search_constraint", "search_active"})
+        self.assertEqual(self.search_classes("/ModularCurve/Q/?level=13",
+                                             "level_type"),
+                         {"search_constraint"})
+
     def test_index_range(self):
         L = self.tc.get("/ModularCurve/Q/?index=100-1000")
         assert "6.144.1-6.b.1.1" in L.get_data(as_text=True)