Fix priority encoder circuit logic

The priority encoder was using any_ge{pos} which ORs bits from position
pos to end, but the correct logic needs any_higher{pos} which ORs bits
from position 0 to pos-1 (all higher-priority positions).

Circuit structure (MSB-first, position 0 = highest priority):
- any_higher{pos}: OR of bits 0 to pos-1
- is_highest{0}: bit[0] directly (MSB always highest if set)
- is_highest{pos}: bit[pos] AND NOT(any_higher{pos}) for pos > 0
- out{bit}: OR of is_highest signals for matching positions

This fixes the 32-bit priority encoder which was failing 18/217 tests.
Both 8-bit and 32-bit models now pass all tests:
- neural_computer.safetensors: 6772/6772 (100%)
- neural_alu32.safetensors: 7256/7256 (100%)

build.py

@@ -724,8 +724,15 @@ def add_priority_encoder_nbits(tensors: Dict[str, torch.Tensor], bits: int) -> N
     """Add N-bit priority encoder circuit.
 
     Finds the position of the highest set bit (0 to bits-1).
+    Position 0 = MSB (highest priority), Position bits-1 = LSB (lowest priority).
     Output is ceil(log2(bits))-bit index + valid flag.
 
+    Circuit structure:
+    1. any_higher{pos}: OR of bits 0 to pos-1 (all higher-priority positions)
+    2. is_highest{pos}: bit[pos] AND NOT(any_higher{pos})
+    3. out{bit}: OR of is_highest{pos} for positions where (pos >> bit) & 1
+    4. valid: OR of all input bits
+
     Args:
         bits: Input width (8, 16, 32, etc.)
     """
@@ -733,18 +740,23 @@ def add_priority_encoder_nbits(tensors: Dict[str, torch.Tensor], bits: int) -> N
     out_bits = max(1, math.ceil(math.log2(bits)))
     prefix = f"combinational.priorityencoder{bits}"
 
-    # Check each bit position (OR gates to detect any bit set at or above position)
-    for pos in range(bits):
-        num_inputs = bits - pos
-        weights = [1.0] * num_inputs
-        add_gate(tensors, f"{prefix}.any_ge{pos}", weights, [-1.0])
-
-    # Priority logic: pos N is highest if bit N is set AND no higher bit is set
-    for pos in range(bits):
+    # any_higher{pos}: OR of all bits at positions 0 to pos-1 (higher priority)
+    # any_higher{0} not needed (no higher bits)
+    # any_higher{1} = bit[0]
+    # any_higher{N} = bit[0] OR bit[1] OR ... OR bit[N-1]
+    for pos in range(1, bits):
+        weights = [1.0] * pos
+        add_gate(tensors, f"{prefix}.any_higher{pos}", weights, [-1.0])
+
+    # is_highest{pos}: bit[pos] is set AND no higher-priority bit is set
+    # is_highest{0} = bit[0] (always highest if set)
+    # is_highest{pos} = bit[pos] AND NOT(any_higher{pos}) for pos > 0
+    for pos in range(1, bits):
         add_gate(tensors, f"{prefix}.is_highest{pos}.not_higher", [-1.0], [0.0])
         add_gate(tensors, f"{prefix}.is_highest{pos}.and", [1.0, 1.0], [-2.0])
 
     # Encode position to output bits
+    # out{bit} = OR of is_highest{pos} for all pos where (pos >> bit) & 1
     for out_bit in range(out_bits):
         weights = []
         for pos in range(bits):

eval.py

@@ -2998,7 +2998,15 @@ class BatchedFitnessEvaluator:
         return scores, total
 
     def _test_priority_encoder_nbits(self, pop: Dict, bits: int, debug: bool) -> Tuple[torch.Tensor, int]:
-        """Test N-bit priority encoder (find highest set bit)."""
+        """Test N-bit priority encoder (find highest set bit).
+
+        The priority encoder is a multi-layer circuit:
+        1. any_higher{pos}: OR of bits 0 to pos-1 (all higher-priority positions)
+        2. is_highest{0}: bit[0] directly (MSB is always highest if set)
+        3. is_highest{pos}: bit[pos] AND NOT(any_higher{pos}) for pos > 0
+        4. out{bit}: OR of is_highest{pos} for all pos where (pos >> bit) & 1
+        5. valid: OR of all input bits
+        """
         import math
         pop_size = next(iter(pop.values())).shape[0]
         scores = torch.zeros(pop_size, device=self.device)
@@ -3035,17 +3043,37 @@ class BatchedFitnessEvaluator:
                 total += 1
 
                 if expected_valid == 1:
+                    any_higher = [None]
+                    for pos in range(1, bits):
+                        w = pop[f'{prefix}.any_higher{pos}.weight'].view(pop_size, -1)
+                        b = pop[f'{prefix}.any_higher{pos}.bias'].view(pop_size)
+                        inp = val_bits[:pos]
+                        out = heaviside((inp * w[:, :len(inp)]).sum(-1) + b)
+                        any_higher.append(out)
+
+                    is_highest = []
+                    for pos in range(bits):
+                        if pos == 0:
+                            is_high = val_bits[0].unsqueeze(0).expand(pop_size)
+                        else:
+                            w_not = pop[f'{prefix}.is_highest{pos}.not_higher.weight'].view(pop_size, -1)
+                            b_not = pop[f'{prefix}.is_highest{pos}.not_higher.bias'].view(pop_size)
+                            not_higher = heaviside(any_higher[pos].unsqueeze(-1) * w_not + b_not).squeeze(-1)
+
+                            w_and = pop[f'{prefix}.is_highest{pos}.and.weight'].view(pop_size, -1)
+                            b_and = pop[f'{prefix}.is_highest{pos}.and.bias'].view(pop_size)
+                            inp = torch.stack([val_bits[pos].expand(pop_size), not_higher], dim=-1)
+                            is_high = heaviside((inp * w_and).sum(-1) + b_and)
+                        is_highest.append(is_high)
+
                     for idx_bit in range(out_bits):
                         try:
-                            w_idx = pop[f'{prefix}.out{idx_bit}.weight']
-                            num_weights = w_idx.numel() // pop_size
-                            w_idx = w_idx.view(pop_size, num_weights)
+                            w_idx = pop[f'{prefix}.out{idx_bit}.weight'].view(pop_size, -1)
                             b_idx = pop[f'{prefix}.out{idx_bit}.bias'].view(pop_size)
-                            relevant_bits = torch.tensor([val_bits[i].item() for i in range(bits)
-                                                         if (i >> idx_bit) & 1],
-                                                        device=self.device, dtype=torch.float32)
-                            if len(relevant_bits) > 0:
-                                out_idx = heaviside((relevant_bits[:w_idx.shape[1]] * w_idx).sum(-1) + b_idx)
+                            relevant = [is_highest[pos] for pos in range(bits) if (pos >> idx_bit) & 1]
+                            if len(relevant) > 0:
+                                inp = torch.stack(relevant[:w_idx.shape[1]], dim=-1)
+                                out_idx = heaviside((inp * w_idx).sum(-1) + b_idx)
                                 expected_bit = (expected_idx >> idx_bit) & 1
                                 if int(out_idx[0].item()) == expected_bit:
                                     scores += 1

neural_alu32.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6efa5b719d55fa8e071c4dacc90bfe5bff7337c6fab952460f4ccdadf237facb
-size 10083624
+oid sha256:2277b9b7ca05aeca4b84da8f8cf48c8ceba9d81ea926a2a1f6be46462fdc9944
+size 10082208

neural_computer.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:812d1833c915945eeb694bca530b075b3e08685bac8646f29e87d26a2d644b88
-size 8436636
+oid sha256:a76635005d7031f01492b1c5d6286dbede39c1ecf08ed4b08daf4e7c3c2fe097
+size 8435820