Fix trig mutation probability: enforce minimum 0.02, restructure logic to properly follow probability

genetic_backend.py

@@ -43,13 +43,16 @@ class EquationGene:
         has_atan = any(self.params.get(k) == 'atan' for k in keys)
         const_delta = constant_mutation_delta * 0.5 if has_atan else constant_mutation_delta
         
-        # For each trig site, decide mutation type based on probability
-        for key in keys:
-            # Use site-specific mutation rate if provided, otherwise use default
-            site_rate = site_mutation_rates.get(key, mutation_rate) if site_mutation_rates else mutation_rate
-            if random.random() < site_rate:
-                # Decide if this should be a trig mutation or constant mutation
-                if random.random() < trig_mutation_prob:
+        # Decide upfront: will this mutation cycle be trig-focused or constant-focused?
+        # This ensures the probability is properly respected
+        use_trig_mutation = random.random() < trig_mutation_prob
+        
+        if use_trig_mutation:
+            # Trig-focused: mutate trig sites, with small chance for constant mutations
+            for key in keys:
+                # Use site-specific mutation rate if provided, otherwise use default
+                site_rate = site_mutation_rates.get(key, mutation_rate) if site_mutation_rates else mutation_rate
+                if random.random() < site_rate:
                     # Trig function mutation
                     old = self.params.get(key)
                     if isinstance(old, str):
@@ -59,36 +62,46 @@ class EquationGene:
                             new = random.choice(choices)
                             self.params[key] = new
                             self.mutation_log.append(f"{key}:{old}->{new}")
-                else:
-                    # Constant mutation instead - find a constant to mutate
-                    if constant_keys:
-                        const_key = random.choice(constant_keys)
-                        old = self.params.get(const_key)
-                        if isinstance(old, (int, float)):
-                            # Randomly increase or decrease
-                            direction = random.choice([-1, 1])
-                            new = old + direction * const_delta
-                            # Keep reasonable bounds (avoid negative divisors, etc.)
-                            if 'div' in const_key.lower():
-                                new = max(0.1, new)  # Prevent zero or negative divisors
-                            elif 'mult' in const_key.lower():
-                                new = max(0.01, new)  # Prevent zero or negative multipliers
-                            self.params[const_key] = new
-                            self.mutation_log.append(f"{const_key}:{old:.3f}->{new:.3f}")
-        
-        # Also allow direct constant mutations (independent of trig site checks)
-        if constant_keys and random.random() < (1.0 - trig_mutation_prob) * mutation_rate:
-            key = random.choice(constant_keys)
-            old = self.params.get(key)
-            if isinstance(old, (int, float)):
-                direction = random.choice([-1, 1])
-                new = old + direction * const_delta
-                if 'div' in key.lower():
-                    new = max(0.1, new)
-                elif 'mult' in key.lower():
-                    new = max(0.01, new)
-                self.params[key] = new
-                self.mutation_log.append(f"{key}:{old:.3f}->{new:.3f}")
+            
+            # Small chance for constant mutations even in trig-focused mode (10% of constant mutation rate)
+            if constant_keys and random.random() < 0.1 * mutation_rate:
+                const_key = random.choice(constant_keys)
+                old = self.params.get(const_key)
+                if isinstance(old, (int, float)):
+                    direction = random.choice([-1, 1])
+                    new = old + direction * const_delta
+                    if 'div' in const_key.lower():
+                        new = max(0.1, new)
+                    elif 'mult' in const_key.lower():
+                        new = max(0.01, new)
+                    self.params[const_key] = new
+                    self.mutation_log.append(f"{const_key}:{old:.3f}->{new:.3f}")
+        else:
+            # Constant-focused: primarily mutate constants, with very small chance for trig mutations
+            # Mutate constants
+            if constant_keys and random.random() < mutation_rate:
+                key = random.choice(constant_keys)
+                old = self.params.get(key)
+                if isinstance(old, (int, float)):
+                    direction = random.choice([-1, 1])
+                    new = old + direction * const_delta
+                    if 'div' in key.lower():
+                        new = max(0.1, new)
+                    elif 'mult' in key.lower():
+                        new = max(0.01, new)
+                    self.params[key] = new
+                    self.mutation_log.append(f"{key}:{old:.3f}->{new:.3f}")
+            
+            # Very small chance for trig mutations in constant-focused mode (5% of trig mutation rate)
+            if keys and random.random() < 0.05 * trig_mutation_prob * mutation_rate:
+                key = random.choice(keys)
+                old = self.params.get(key)
+                if isinstance(old, str):
+                    choices = [f for f in TRIG_FUNCS if f != old]
+                    if choices:
+                        new = random.choice(choices)
+                        self.params[key] = new
+                        self.mutation_log.append(f"{key}:{old}->{new}")
 
 class GeneticEquationEvolver:
     def __init__(self, population_size: int = 16, elite_size: int = 4):
@@ -223,13 +236,15 @@ class GeneticEquationEvolver:
     
     def get_trig_mutation_probability(self) -> float:
         """Calculate probability of trig mutations vs constant mutations.
-        Always decays from base value using square root, based on generations since base was set."""
+        Always decays from base value using square root, based on generations since base was set.
+        Minimum probability is 0.02."""
         if self.generation == self.trig_mutation_prob_base_generation:
             # Same generation as when base was set, return base value
-            return self.trig_mutation_prob_base
+            return max(0.02, self.trig_mutation_prob_base)
         # Decay from base: base / sqrt(generations_since_base_set + 1)
         generations_since_base = self.generation - self.trig_mutation_prob_base_generation
-        return self.trig_mutation_prob_base / math.sqrt(generations_since_base + 1)
+        prob = self.trig_mutation_prob_base / math.sqrt(generations_since_base + 1)
+        return max(0.02, prob)  # Ensure minimum of 0.02
     
     def get_constant_mutation_delta(self) -> float:
         """Calculate mutation delta for constants.