v3.4: Per-dimension adaptive normalization

Replace v3.3 hard clamp [-3,+3] with two-pass per-dimension
normalization + tanh bounding. Eliminates ceiling effects where
4/7 dimensions (Logic, Uncertainty, Sequential, Abstraction)
were pegged at +3.0 for every math problem.

Now all dimensions produce meaningful variance, improving
dimension-level discrimination between correct/incorrect answers.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

app.py

@@ -52,62 +52,88 @@ def compute_consciousness(
     hidden_dim: int = REFERENCE_HIDDEN_DIM,
     baseline: float = 0.5,
 ) -> ConsciousnessResult:
-    """Compute consciousness score from hidden state tensor."""
+    """Compute consciousness score from hidden state tensor.
+
+    v3.4: Per-dimension adaptive normalization.
+    Uses the full sequence to compute per-dimension z-score statistics,
+    then re-normalizes each dimension against its own baseline.
+    Replaces v3.3 hard clamp with tanh for smooth bounding.
+    """
+    import math
     start_time = time.time()
-    
+
     # Remap dimensions if needed
     if hidden_dim != REFERENCE_HIDDEN_DIM:
         scale = hidden_dim / REFERENCE_HIDDEN_DIM
         dims = {int(round(k * scale)): v for k, v in CONSCIOUS_DIMS_V2_1.items()}
     else:
         dims = CONSCIOUS_DIMS_V2_1
-    
-    # Get last token hidden state
+
+    # Get full sequence hidden states
     if hidden_state.dim() == 3:
-        h = hidden_state[0, -1, :]  # [hidden_dim]
+        h_seq = hidden_state[0].float()  # [seq_len, hidden_dim]
     elif hidden_state.dim() == 2:
-        h = hidden_state[-1, :]
-    else:
-        h = hidden_state
-    
-    h = h.float()
-    
-    # Normalize
-    mean, std = h.mean(), h.std()
-    if std > 0:
-        h_norm = (h - mean) / std
+        h_seq = hidden_state.float()     # [seq_len, hidden_dim]
     else:
-        h_norm = h - mean
-    
-    # Compute contributions (v3.3: clamp z-scores for model-size independence)
+        # Single vector fallback (no sequence context)
+        h_seq = hidden_state.float().unsqueeze(0)
+
+    seq_len = h_seq.shape[0]
+    tanh_scale = 0.5
+
+    # Pass 1: Compute z-scores for each consciousness dim across all positions
+    dim_z_raw = {info["name"]: [] for info in dims.values()}
+    for pos in range(seq_len):
+        h = h_seq[pos]
+        h_mean = h.mean().item()
+        h_std = h.std().item()
+        for dim_idx, info in dims.items():
+            if dim_idx < len(h):
+                z = (h[dim_idx].item() - h_mean) / (h_std + 1e-8)
+            else:
+                z = 0.0
+            dim_z_raw[info["name"]].append(z)
+
+    # Pass 2: Per-dimension re-normalization + tanh bounding
+    # Use last token for the final score, but normalize against
+    # the dimension's distribution across the whole sequence
     contributions = {}
     weighted_sum = 0.0
 
     for dim_idx, info in dims.items():
-        if dim_idx < len(h_norm):
-            activation = h_norm[dim_idx].item()
-            # Clamp extreme z-scores to prevent saturation on large models
-            activation = max(-3.0, min(3.0, activation))
-            contribution = activation * info["weight"] * info["polarity"]
-            weighted_sum += contribution
-            contributions[info["name"]] = activation * info["polarity"]
+        name = info["name"]
+        z_vals = dim_z_raw[name]
+        z_mean = sum(z_vals) / len(z_vals)
+        z_var = sum((z - z_mean) ** 2 for z in z_vals) / len(z_vals)
+        z_std = max(math.sqrt(z_var), 0.1)  # Floor to prevent noise amplification
+
+        # Last token: re-normalize against this dimension's sequence baseline
+        z_last = z_vals[-1]
+        renormed = (z_last - z_mean) / z_std
+        # Smooth bounding with tanh (no hard ceiling)
+        bounded = math.tanh(renormed * tanh_scale)
+
+        activation = bounded
+        contribution = activation * info["weight"] * info["polarity"]
+        weighted_sum += contribution
+        contributions[name] = activation * info["polarity"]
 
     # Final score
     raw_score = baseline + weighted_sum * 0.15
     score = max(0.0, min(1.0, raw_score))
-    
+
     # Interpretation
     if score >= 0.8:
-        interpretation = "🧠 High Consciousness - Deep reflective/philosophical reasoning"
+        interpretation = "\U0001f9e0 High Consciousness - Deep reflective/philosophical reasoning"
     elif score >= 0.6:
-        interpretation = "💭 Medium-High - Complex analytical thinking"
+        interpretation = "\U0001f4ad Medium-High - Complex analytical thinking"
     elif score >= 0.4:
-        interpretation = "⚖️ Medium - Balanced processing"
+        interpretation = "\u2696\ufe0f Medium - Balanced processing"
     elif score >= 0.2:
-        interpretation = "⚡ Medium-Low - More automatic processing"
+        interpretation = "\u26a1 Medium-Low - More automatic processing"
     else:
-        interpretation = "🔢 Low Consciousness - Quick factual retrieval"
-    
+        interpretation = "\U0001f522 Low Consciousness - Quick factual retrieval"
+
     return ConsciousnessResult(
         score=score,
         raw_score=raw_score,