trig tokens: quantized-freq structural identity

Replace the trig-only `freq`-stripping branch in `Term.factors_labels`
and the matching defensive code in `EqRightPartSelector.simplify_equation`
with a uniform `Factor.structural_label` that bucketises continuous-
tolerance params (e.g. trig `freq`) via `equality_ranges`. Same
quantization powers `factors_labels_without_power` for the simplify
common-factor scan. `cache_label` is unchanged and continues to key
the tensor cache.

No behavioural change for the thesis 14 systems: every system uses a
narrow `freq=(v-eps, v+eps)` interval, so all sampled freq values land
in bucket 0 and produce the same structural identity as the prior
freq-stripping logic.

Author: Gromwud

epde/operators/common/right_part_selection.py

@@ -125,69 +125,60 @@ def simplify_equation(self, objective: Equation):
         nonzero_terms.append(objective.structure[objective.target_idx])
         equation_terms = [term.factors_labels_without_power for term in nonzero_terms]
 
-        # If amount nonzero terms is more than one -- get their intersection
-        if len(equation_terms) > 1:
-            common_factors = list(frozenset.intersection(*equation_terms))
-            if len(common_factors) > 0:
-                for common_factor in common_factors:
-                    # Find if this intersection in the same dimension (i.e. trigonometry functions) + it's minimal order
-                    min_order = np.inf
-                    common_dim = []
-                    for term in nonzero_terms:
-                        for factor in term.structure:
-                            if len(factor.params) == 1:
-                                factor_label = (factor.cache_label[0])
+        if len(equation_terms) <= 1:
+            return False
+        common_factors = list(frozenset.intersection(*equation_terms))
+        if not common_factors:
+            return False
+
+        for common_factor in common_factors:
+            # Min power across the matching factor in every nonzero term.
+            min_order = np.inf
+            for term in nonzero_terms:
+                for factor in term.structure:
+                    if factor.structural_label_without_power == common_factor:
+                        if factor.cache_label[1][0] < min_order:
+                            min_order = factor.cache_label[1][0]
+
+            # Reduce order of common factor in every term; drop zero-power factors.
+            max_iter = 100
+            for term in nonzero_terms:
+                factors_simplified = []
+                for factor in term.structure:
+                    if factor.structural_label_without_power == common_factor:
+                        for i, value in enumerate(factor.params_description):
+                            if factor.params_description[i]["name"] == "power":
+                                factor.params[i] -= min_order
+                                if factor.params[i] == 0:
+                                    factors_simplified.append(factor)
                             else:
-                                factor_label = (factor.cache_label[0], (factor.cache_label[1][-1]))
-                            if factor_label == common_factor:
-                                if len(factor.params) > 1:
-                                    common_dim.append(factor.params[-1])
-                                if factor.cache_label[1][0] < min_order:
-                                    min_order = factor.cache_label[1][0]
-                    if len(set(common_dim)) < 2:
-                        # If dimension is the same -- reduce order of terms' factor
-                        max_iter = 100
-                        for term in nonzero_terms:
-                            factors_simplified = []
-                            for factor in term.structure:
-                                if len(factor.params) == 1:
-                                    factor_label = (factor.cache_label[0])
-                                else:
-                                    factor_label = (factor.cache_label[0], (factor.cache_label[1][-1]))
-                                if factor_label == common_factor:
-                                    for i, value in enumerate(factor.params_description):
-                                        if factor.params_description[i]["name"] == "power":
-                                            factor.params[i] -= min_order
-                                            if factor.params[i] == 0:
-                                                factors_simplified.append(factor)
-                                        else:
-                                            continue
-                            term.structure = [factor for factor in term.structure if factor not in factors_simplified]
-                            term.reset_saved_state()
-
-                            # If term's order became zero -- replace term.
-                            # Cap retries so a constrained token pool can't
-                            # deadlock the optimizer (same hazard fixed in
-                            # ``enforce_rps_uniqueness``).
-                            attempts = 0
-                            while attempts < max_iter:
-                                empty = len(term.structure) == 0
-                                not_meaningful = not term.contains_meaningful()
-                                signatures = {t.factors_labels for t in objective.structure}
-                                duplicate = len(signatures) != len(objective.structure)
-                                if not (empty or not_meaningful or duplicate):
-                                    break
-                                term.randomize()
-                                attempts += 1
-
-                        # Structure changed: invalidate stale fitness /
-                        # weights / AIC caches while leaving RPS to the
-                        # caller's outer loop.
-                        try:
-                            objective.reset_state(reset_right_part=False)
-                        except TypeError:
-                            objective.reset_state()
-                        return True
+                                continue
+                term.structure = [factor for factor in term.structure if factor not in factors_simplified]
+                term.reset_saved_state()
+
+                # If term's order became zero -- replace term.
+                # Cap retries so a constrained token pool can't
+                # deadlock the optimizer (same hazard fixed in
+                # ``enforce_rps_uniqueness``).
+                attempts = 0
+                while attempts < max_iter:
+                    empty = len(term.structure) == 0
+                    not_meaningful = not term.contains_meaningful()
+                    signatures = {t.factors_labels for t in objective.structure}
+                    duplicate = len(signatures) != len(objective.structure)
+                    if not (empty or not_meaningful or duplicate):
+                        break
+                    term.randomize()
+                    attempts += 1
+
+            # Structure changed: invalidate stale fitness /
+            # weights / AIC caches while leaving RPS to the
+            # caller's outer loop.
+            try:
+                objective.reset_state(reset_right_part=False)
+            except TypeError:
+                objective.reset_state()
+            return True
         return False
 
     def use_default_tags(self):

epde/structure/factor.py

@@ -273,6 +273,48 @@ def cache_label(self):
         cache_label = factor_params_to_str(self)
         return cache_label
 
+    def _quantized_params(self, drop_power: bool = False) -> tuple:
+        """Return params with continuous-tolerance ones quantized into bucket
+        indices and exact-equality ones passed through. Continuous params
+        (those with ``equality_ranges[name] > 0``, e.g. trig ``freq``) get
+        ``int((v - bounds[0]) / equality_ranges[name])``; exact-equality
+        params (``power``, ``dim``) stay numeric. When ``drop_power=True``
+        the param named ``'power'`` is omitted from the result tuple.
+        """
+        parts = []
+        for i in range(len(self.params)):
+            name = self.params_description[i]['name']
+            if drop_power and name == 'power':
+                continue
+            v = self.params[i]
+            tol = self.equality_ranges.get(name, 0)
+            if tol > 0:
+                origin = self.params_description[i]['bounds'][0]
+                parts.append(int((v - origin) / tol))
+            else:
+                parts.append(v)
+        return tuple(parts)
+
+    @property
+    def structural_label(self):
+        """Hashable canonical identity for structural dedup.
+
+        Sits next to ``cache_label`` (which keys the tensor cache and
+        must stay exact). Continuous params are quantized into bucket
+        indices so set-based dedup and ``Factor.__eq__``'s tolerance
+        comparison agree.
+        """
+        return (self.cache_label[0], self._quantized_params(drop_power=False))
+
+    @property
+    def structural_label_without_power(self):
+        """``structural_label`` with the ``power`` param dropped.
+
+        Used by ``simplify_equation`` to find shared factors across
+        terms regardless of their individual powers.
+        """
+        return (self.cache_label[0], self._quantized_params(drop_power=True))
+
     @property
     def name(self):
         form = self.label + '{'

epde/structure/main_structures.py

@@ -399,39 +399,25 @@ def __deepcopy__(self, memo=None):
 
     @property
     def factors_labels_without_power(self) -> frozenset:
-        """Return a frozenset of factor labels with the power parameter dropped.
+        """Return a frozenset of structural labels with the ``power`` param dropped.
 
-        Each entry is either the cache label tuple or its head plus the trailing
-        param (when the factor has more than one parameter). Used to compare
-        terms for structural identity ignoring power differences.
+        Identity is delegated to ``Factor.structural_label_without_power``,
+        which quantizes continuous-tolerance params (e.g. trig ``freq``)
+        into bucket indices so structural dedup stays consistent with
+        ``Factor.__eq__``.
         """
-        described = set()
-        for factor in self.structure:
-            if len(factor.params) == 1:
-                factor_label = (factor.cache_label[0])
-            else:
-                factor_label = (factor.cache_label[0], (factor.cache_label[1][-1]))
-            described.add(factor_label)
-        described = frozenset(described)
-        return described
+        return frozenset(factor.structural_label_without_power for factor in self.structure)
 
     @property
     def factors_labels(self) -> frozenset:
-        """Return a frozenset of canonical labels for each factor in the term.
+        """Return a frozenset of structural labels for each factor in the term.
 
-        Trigonometric factors collapse the ``freq`` parameter (kept fungible
-        across small frequency ranges); other factors use ``factor.cache_label``
-        directly. Used as a hashable identity for set/membership checks.
+        Identity is delegated to ``Factor.structural_label``, which
+        bucketises continuous-tolerance params (e.g. trig ``freq``) so
+        within-bucket differences don't fracture structural identity.
+        Used as a hashable identity for set/membership checks.
         """
-        described = set()
-        for factor in self.structure:
-            if factor.ftype == 'trigonometric':
-                label = (factor.cache_label[0], tuple(factor.cache_label[1][i] for i, param in factor.params_description.items() if param['name'] != 'freq'))
-                described.add(label)
-            else:
-                described.add(factor.cache_label)
-        described = frozenset(described)
-        return described
+        return frozenset(factor.structural_label for factor in self.structure)
 
     @property
     def term_label_without_power(self):