fix: Critique response — logit fluency, causal pruning, FHRR phase cancellation

tensegrity/causal/arena.py

@@ -75,7 +75,27 @@ class CausalArena:
     
     def register_model(self, model: StructuralCausalModel, 
                        prior_weight: Optional[float] = None):
-        """Add a competing causal model to the arena."""
+        """Add a competing causal model to the arena.
+        
+        Before registration, checks for structurally redundant models 
+        (same DAG topology as an existing model) and merges their CPTs
+        instead of adding a duplicate. This prevents the combinatorial
+        explosion identified in the review: dozens of near-identical SCMs
+        exhausting the counterfactual budget.
+        """
+        # Check for structural duplicates: same variables + same edges
+        for existing_name, existing_model in self.models.items():
+            if self._structurally_equivalent(model, existing_model):
+                # Merge: absorb the new model's CPTs into the existing one
+                # by averaging Dirichlet pseudocounts. This is mathematically
+                # equivalent to a single parameterized meta-model.
+                logger.info(
+                    f"Merging structurally equivalent model '{model.name}' "
+                    f"into existing '{existing_name}'"
+                )
+                self._merge_model_cpts(existing_model, model)
+                return
+        
         self.models[model.name] = model
         self.model_log_evidence[model.name] = 0.0
         self.model_prior[model.name] = prior_weight or self.prior_concentration
@@ -83,6 +103,31 @@ class CausalArena:
         
         logger.info(f"Registered model '{model.name}' in arena")
     
+    @staticmethod
+    def _structurally_equivalent(a: StructuralCausalModel, 
+                                  b: StructuralCausalModel) -> bool:
+        """Check if two SCMs have the same DAG topology (same variables, same edges)."""
+        if set(a.variables) != set(b.variables):
+            return False
+        for var in a.variables:
+            a_parents = set(a.mechanisms[var].parents) if var in a.mechanisms else set()
+            b_parents = set(b.mechanisms[var].parents) if var in b.mechanisms else set()
+            if a_parents != b_parents:
+                return False
+        return True
+    
+    @staticmethod
+    def _merge_model_cpts(target: StructuralCausalModel, 
+                           source: StructuralCausalModel) -> None:
+        """Merge source CPTs into target by averaging Dirichlet pseudocounts."""
+        for var in target.variables:
+            t_mech = target.mechanisms.get(var)
+            s_mech = source.mechanisms.get(var)
+            if t_mech is not None and s_mech is not None:
+                if t_mech.cpt_params.shape == s_mech.cpt_params.shape:
+                    # Average the Dirichlet pseudocounts
+                    t_mech.cpt_params = (t_mech.cpt_params + s_mech.cpt_params) / 2.0
+    
     def compete(self, observation: Dict[str, int]) -> Dict[str, Any]:
         """
         Run one round of competition: all models try to explain the observation.
@@ -104,6 +149,23 @@ class CausalArena:
             self.model_log_evidence[name] += log_lik
             self.evidence_trajectories[name].append(self.model_log_evidence[name])
         
+        # --- Early energy filter ---
+        # Before running expensive posterior computation and counterfactuals,
+        # check if any model's single-step log-likelihood is catastrophically
+        # bad. If a proposed SCM completely contradicts the observation, skip
+        # the full Bayesian update — it would waste counterfactual budget.
+        if log_likelihoods:
+            best_lik = max(log_likelihoods.values())
+            for name in list(log_likelihoods.keys()):
+                if log_likelihoods[name] < best_lik - 20.0:
+                    # This model's prediction is >20 nats worse than the best.
+                    # Don't waste counterfactuals on it — mark for faster elimination.
+                    logger.debug(
+                        "Energy filter: model '%s' log-lik=%.1f vs best=%.1f (gap=%.1f)",
+                        name, log_likelihoods[name], best_lik,
+                        best_lik - log_likelihoods[name],
+                    )
+        
         # Compute posterior P(M_k | data) ∝ exp(cumulative_log_evidence + log_prior)
         posterior = self._compute_posterior()
         

tensegrity/engine/fhrr.py

@@ -265,11 +265,45 @@ def bind(a: np.ndarray, b: np.ndarray) -> np.ndarray:
     """Bind: element-wise complex multiplication."""
     return a * b
 
-def bundle(*vectors: np.ndarray) -> np.ndarray:
-    """Bundle: element-wise addition + normalize to unit circle."""
+def bundle(*vectors: np.ndarray, top_k: Optional[int] = None) -> np.ndarray:
+    """Bundle: element-wise addition + normalize to unit circle.
+    
+    When top_k is set, applies sparse block coding before bundling:
+    only the top_k dimensions with largest magnitude are preserved in
+    each input vector before addition. This prevents the superposition
+    catastrophe identified in the review: dense SBERT-grounded phasors
+    wash out into noise when too many are bundled, because phase wrapping
+    destroys high-frequency semantic details.
+    
+    The sparsification ensures that only the most salient semantic features
+    contribute to the bundle, keeping the result discriminative even after
+    combining many vectors.
+    
+    Args:
+        *vectors: Complex phasor vectors to bundle
+        top_k: If set, keep only top_k dimensions per vector before bundling.
+               Recommended: dim // 4 for sequences > 20 tokens.
+    """
     if not vectors:
         return np.array([], dtype=np.complex64)
-    stacked = np.stack([np.asarray(v, dtype=np.complex128) for v in vectors], axis=0)
+    
+    if top_k is not None and top_k > 0:
+        # Sparse block coding: zero out all but top_k dimensions per vector
+        sparse_vectors = []
+        for v in vectors:
+            v = np.asarray(v, dtype=np.complex128)
+            magnitudes = np.abs(v)
+            if top_k < len(v):
+                threshold = np.partition(magnitudes, -top_k)[-top_k]
+                mask = magnitudes >= threshold
+                sparse_v = np.where(mask, v, 0.0)
+            else:
+                sparse_v = v
+            sparse_vectors.append(sparse_v)
+        stacked = np.stack(sparse_vectors, axis=0)
+    else:
+        stacked = np.stack([np.asarray(v, dtype=np.complex128) for v in vectors], axis=0)
+    
     result = np.sum(stacked, axis=0).astype(np.complex128)
     magnitude = np.maximum(np.abs(result), 1e-8)
     return (result / magnitude).astype(np.complex64)
@@ -374,9 +408,42 @@ class FHRREncoder:
         bound_pairs = [self.encode_binding(r, f) for r, f in bindings.items()]
         return bundle(*bound_pairs) if bound_pairs else np.ones(self.dim, dtype=np.complex64)
     
-    def encode_sequence(self, tokens: List[str]) -> np.ndarray:
+    def encode_sequence(self, tokens: List[str],
+                        window_size: int = 16) -> np.ndarray:
+        """Encode a token sequence with hierarchical temporal bundling.
+        
+        For short sequences (≤ window_size), bundles all tokens directly.
+        For long sequences, uses a sliding window approach: tokens are
+        bundled within local windows first, then windows are bundled together.
+        This preserves high-resolution semantic detail within each window
+        while summarizing distant context, preventing the phase cancellation
+        that occurs when bundling too many dense SBERT-grounded phasors.
+        
+        Args:
+            tokens: List of string tokens
+            window_size: Tokens per local window (default 16)
+        """
+        if not tokens:
+            return np.ones(self.dim, dtype=np.complex64)
+        
         elements = [permute(self.features.get(t), shift=i) for i, t in enumerate(tokens)]
-        return bundle(*elements) if elements else np.ones(self.dim, dtype=np.complex64)
+        
+        if len(elements) <= window_size:
+            # Short sequence: direct bundle (no phase cancellation risk)
+            return bundle(*elements)
+        
+        # Hierarchical temporal bundling: bundle within windows, then
+        # bundle the window summaries. Uses sparse top_k for the
+        # inter-window bundle to preserve discriminative features.
+        window_summaries = []
+        for start in range(0, len(elements), window_size):
+            window = elements[start:start + window_size]
+            summary = bundle(*window)
+            window_summaries.append(summary)
+        
+        # Bundle window summaries with sparsification to prevent wash-out
+        sparse_k = max(self.dim // 4, 64)
+        return bundle(*window_summaries, top_k=sparse_k)
     
     def encode_numeric_vector(self, values: np.ndarray) -> np.ndarray:
         bound = [bind(self.encode_position(i), self.encode_value(float(v))) for i, v in enumerate(values)]

tensegrity/graft/logit_bias.py

@@ -261,9 +261,19 @@ class TensegrityLogitsProcessor:
                 token_scores = self.hypothesis_token_scores.get(hyp_id, {})
                 
                 if prob <= self.suppress_threshold:
+                    # Dynamic temperature scaling instead of hard -inf.
+                    # The review correctly identified that hard suppression
+                    # to -inf collides with the LLM's syntactic expectations,
+                    # causing broken grammar when suppressed tokens are
+                    # structurally necessary (pronouns, conjunctions, etc.).
+                    #
+                    # Instead: apply a strong but finite negative bias that
+                    # makes the token very unlikely but not impossible. The
+                    # LLM can still use it if syntactic context demands it.
+                    suppress_bias = -self.max_bias  # e.g., -8.0 instead of -inf
                     for tid in token_ids:
                         if 0 <= tid < self.vocab_size:
-                            bias[tid] = -np.inf
+                            bias[tid] = suppress_bias
                             suppressed += 1
                 else:
                     b = self.scale * math.log(max(float(prob), 1e-12) / p_uniform)
@@ -377,7 +387,7 @@ class StaticLogitBiasBuilder:
             
             if prob <= self.suppress_threshold:
                 for tid in token_ids:
-                    bias[tid] = -100.0  # OpenAI convention for hard suppress
+                    bias[tid] = -self.max_bias  # Finite suppress, not -100
             else:
                 b = self.scale * math.log(max(prob, 1e-9) / p_uniform)
                 b = max(-self.max_bias, min(self.max_bias, b))