Full ternary: rebuild modular detectors and drop pattern_recognition

quantize.py --ternary now also restructures the modular and
pattern_recognition seed-file content. The two pattern_recognition
gates (leadingones, trailingones) had no eval coverage and no
downstream consumers; they are dropped.

For each modulus N in {3, 5, 6, 7, 9, 10, 11, 12} the legacy
layer1.geq{i} / layer1.leq{i} / layer2.eq{i} / layer3.or chain (which
used positional weights up to +-10) is replaced with a bit-cascaded
equality detector per multiple of N in [0, 256) followed by an OR
across detectors. The new structure uses only weights in {-1, 0, 1}:

modular.mod{N}.eq.k{k}.bit{i}.match per-bit "x[i] == k[i]"
(identity buffer if k[i]=1,
NOT if k[i]=0)
modular.mod{N}.eq.k{k}.all AND of all 8 bit-matches
modular.mod{N} OR over all per-multiple
match outputs

eval._test_modular gained a third path that walks the new structure
ahead of the single-layer and legacy multi-layer fallbacks.

Result on the canonical: 0 weight tensors remain non-ternary across
the entire library. Every threshold gate in the file now uses only
weights in {-1, 0, 1} with integer biases. All 18 variants rebuilt
and pass eval_all.py at 100% fitness.

eval.py

@@ -2538,23 +2538,58 @@ class BatchedFitnessEvaluator:
     # =========================================================================
 
     def _test_modular(self, pop: Dict, mod: int, debug: bool) -> Tuple[torch.Tensor, int]:
-        """Test modular divisibility circuit (multi-layer for non-powers-of-2)."""
+        """Test modular divisibility circuit.
+
+        Three structures supported, in order of preference:
+          1. Bit-cascade equality per multiple (ternary): {prefix}.eq.k{k}.bit{i}.match
+             + {prefix}.eq.k{k}.all + final OR at {prefix}
+          2. Single-layer (powers of 2): {prefix}.weight directly applied
+          3. Legacy layer1.geq/leq + layer2.eq + layer3.or (multi-layer non-ternary)
+        """
         pop_size = next(iter(pop.values())).shape[0]
         prefix = f'modular.mod{mod}'
 
-        # Test 0-255
         inputs = torch.stack([((self.mod_test >> (7 - i)) & 1).float() for i in range(8)], dim=1)
         expected = ((self.mod_test % mod) == 0).float()
+        out = None
 
-        # Try single layer first (powers of 2)
-        try:
-            w = pop[f'{prefix}.weight']
-            b = pop[f'{prefix}.bias']
-            out = heaviside(inputs @ w.view(pop_size, -1).T + b.view(pop_size))
-        except KeyError:
-            # Multi-layer structure: layer1 (geq/leq) -> layer2 (eq) -> layer3 (or)
+        # 1. Try ternary bit-cascade-equality structure
+        multiples = list(range(0, 256, mod))
+        if (multiples
+                and f'{prefix}.eq.k{multiples[0]}.all.weight' in pop
+                and f'{prefix}.weight' in pop):
+            try:
+                match_outputs = []
+                for k in multiples:
+                    per_bit = []
+                    for i in range(8):
+                        bit_in = inputs[:, i].unsqueeze(1).expand(-1, pop_size)
+                        w = pop[f'{prefix}.eq.k{k}.bit{i}.match.weight'].view(pop_size)
+                        b = pop[f'{prefix}.eq.k{k}.bit{i}.match.bias'].view(pop_size)
+                        per_bit.append(heaviside(bit_in * w + b))
+                    stacked = torch.stack(per_bit, dim=-1)
+                    w_and = pop[f'{prefix}.eq.k{k}.all.weight'].view(pop_size, 8)
+                    b_and = pop[f'{prefix}.eq.k{k}.all.bias'].view(pop_size)
+                    match_outputs.append(heaviside((stacked * w_and).sum(-1) + b_and))
+                or_in = torch.stack(match_outputs, dim=-1)
+                w_or = pop[f'{prefix}.weight'].view(pop_size, len(multiples))
+                b_or = pop[f'{prefix}.bias'].view(pop_size)
+                out = heaviside((or_in * w_or).sum(-1) + b_or)
+            except (KeyError, RuntimeError):
+                out = None
+
+        # 2. Single-layer fallback
+        if out is None:
+            try:
+                w = pop[f'{prefix}.weight']
+                b = pop[f'{prefix}.bias']
+                out = heaviside(inputs @ w.view(pop_size, -1).T + b.view(pop_size))
+            except (KeyError, RuntimeError):
+                out = None
+
+        # 3. Legacy multi-layer fallback
+        if out is None:
             try:
-                # Layer 1: geq and leq neurons
                 geq_outputs = {}
                 leq_outputs = {}
                 i = 0
@@ -2563,7 +2598,7 @@ class BatchedFitnessEvaluator:
                     if f'{prefix}.layer1.geq{i}.weight' in pop:
                         w = pop[f'{prefix}.layer1.geq{i}.weight'].view(pop_size, -1)
                         b = pop[f'{prefix}.layer1.geq{i}.bias'].view(pop_size)
-                        geq_outputs[i] = heaviside(inputs @ w.T + b)  # [256, pop_size]
+                        geq_outputs[i] = heaviside(inputs @ w.T + b)
                         found = True
                     if f'{prefix}.layer1.leq{i}.weight' in pop:
                         w = pop[f'{prefix}.layer1.leq{i}.weight'].view(pop_size, -1)
@@ -2577,29 +2612,22 @@ class BatchedFitnessEvaluator:
                 if not geq_outputs and not leq_outputs:
                     return torch.zeros(pop_size, device=self.device), 0
 
-                # Layer 2: eq neurons (AND of geq and leq for same index)
                 eq_outputs = []
                 i = 0
                 while f'{prefix}.layer2.eq{i}.weight' in pop:
                     w = pop[f'{prefix}.layer2.eq{i}.weight'].view(pop_size, -1)
                     b = pop[f'{prefix}.layer2.eq{i}.bias'].view(pop_size)
-                    # Input is [geq_i, leq_i]
                     eq_in = torch.stack([geq_outputs.get(i, torch.zeros(256, pop_size, device=self.device)),
                                         leq_outputs.get(i, torch.zeros(256, pop_size, device=self.device))], dim=-1)
-                    eq_out = heaviside((eq_in * w).sum(-1) + b)
-                    eq_outputs.append(eq_out)
+                    eq_outputs.append(heaviside((eq_in * w).sum(-1) + b))
                     i += 1
-
                 if not eq_outputs:
                     return torch.zeros(pop_size, device=self.device), 0
-
-                # Layer 3: OR of all eq outputs
-                eq_stack = torch.stack(eq_outputs, dim=-1)  # [256, pop_size, num_eq]
+                eq_stack = torch.stack(eq_outputs, dim=-1)
                 w3 = pop[f'{prefix}.layer3.or.weight'].view(pop_size, -1)
                 b3 = pop[f'{prefix}.layer3.or.bias'].view(pop_size)
-                out = heaviside((eq_stack * w3).sum(-1) + b3)  # [256, pop_size]
-
-            except Exception as e:
+                out = heaviside((eq_stack * w3).sum(-1) + b3)
+            except Exception:
                 return torch.zeros(pop_size, device=self.device), 0
 
         correct = (out == expected.unsqueeze(1)).float().sum(0)

neural_computer.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:cebab4da35327fd33df5d8c51b94b2aa78c2fa4024447a3d708c17abe16988de
-size 27129497
+oid sha256:a4333d8f1ea13945e129711733b7f79e96a9d876f40342db1e1634fdd2d85056
+size 27674339

quantize.py

@@ -79,6 +79,76 @@ def _min_signed_int_dtype(tensor: torch.Tensor) -> torch.dtype:
     return torch.int64
 
 
+def _ternarize_modular_and_patterns(
+    tensors: Dict[str, torch.Tensor],
+) -> Tuple[Dict[str, torch.Tensor], Dict]:
+    """Replace seed-file modular detectors and pattern_recognition gates
+    with bit-cascade-equivalent ternary structures.
+
+    Modular: for each modulus N in {3,5,6,7,9,10,11,12}, replace the
+    layer1.geq{i}/layer1.leq{i}/layer2.eq{i}/layer3.or chain with a
+    bit-cascade equality detector per multiple of N in [0, 256), then
+    OR all detectors together. Top-level gate stays named
+    `modular.mod{N}` (a multi-input OR over per-multiple matches).
+
+    Pattern_recognition.leadingones / trailingones are dropped: they are
+    seed-file artifacts with no eval coverage and no downstream
+    consumers in this codebase.
+    """
+    new_tensors = dict(tensors)
+    fixed = 0
+
+    # --- pattern_recognition: drop leadingones/trailingones ---
+    pr_dropped = 0
+    for k in list(new_tensors.keys()):
+        if (k.startswith("pattern_recognition.leadingones")
+                or k.startswith("pattern_recognition.trailingones")):
+            del new_tensors[k]
+            pr_dropped += 1
+
+    # --- modular: rebuild as ternary bit-cascade equality per multiple ---
+    moduli = [3, 5, 6, 7, 9, 10, 11, 12]
+    mod_gates_added = 0
+    for mod in moduli:
+        prefix = f"modular.mod{mod}"
+        # Drop old structure
+        for k in list(new_tensors.keys()):
+            if k.startswith(prefix + "."):
+                del new_tensors[k]
+
+        multiples = list(range(0, 256, mod))
+        # Per-bit match gates + per-multiple AND
+        for k in multiples:
+            for i in range(8):  # i=0 is MSB (matches inputs MSB-first ordering)
+                k_bit = (k >> (7 - i)) & 1
+                if k_bit == 1:
+                    # bit_match = x[i]: H(x - 0.5) ~~ identity for binary;
+                    # use weight=1, bias=-1 -> H(x-1): x=0 -> 0, x=1 -> 1.
+                    new_tensors[f"{prefix}.eq.k{k}.bit{i}.match.weight"] = torch.tensor([1.0], dtype=torch.float64)
+                    new_tensors[f"{prefix}.eq.k{k}.bit{i}.match.bias"] = torch.tensor([-1.0], dtype=torch.float64)
+                else:
+                    # bit_match = NOT x[i]: weight=-1, bias=0 -> H(-x): x=0 -> 1, x=1 -> 0.
+                    new_tensors[f"{prefix}.eq.k{k}.bit{i}.match.weight"] = torch.tensor([-1.0], dtype=torch.float64)
+                    new_tensors[f"{prefix}.eq.k{k}.bit{i}.match.bias"] = torch.tensor([0.0], dtype=torch.float64)
+                mod_gates_added += 1
+            # AND of all 8 bit-matches: weights [1]*8, bias -8
+            new_tensors[f"{prefix}.eq.k{k}.all.weight"] = torch.tensor([1.0] * 8, dtype=torch.float64)
+            new_tensors[f"{prefix}.eq.k{k}.all.bias"] = torch.tensor([-8.0], dtype=torch.float64)
+            mod_gates_added += 1
+
+        # Final OR over all per-multiple match outputs
+        m = len(multiples)
+        new_tensors[f"{prefix}.weight"] = torch.tensor([1.0] * m, dtype=torch.float64)
+        new_tensors[f"{prefix}.bias"] = torch.tensor([-1.0], dtype=torch.float64)
+        mod_gates_added += 1
+
+    return new_tensors, {
+        "pattern_recognition_dropped": pr_dropped,
+        "modular_gates_added": mod_gates_added,
+        "modular_moduli": len(moduli),
+    }
+
+
 def _ternarize_buffers(
     tensors: Dict[str, torch.Tensor],
 ) -> Tuple[Dict[str, torch.Tensor], Dict]:
@@ -146,6 +216,10 @@ def quantize_tensors(
     if ternary:
         tensors, ternary_stats = _ternarize_buffers(tensors)
         ternary_stats["applied"] = True
+        # Also rebuild modular detectors and drop pattern_recognition stragglers.
+        tensors, mod_stats = _ternarize_modular_and_patterns(tensors)
+        ternary_stats["modular_gates_added"] = mod_stats["modular_gates_added"]
+        ternary_stats["pattern_recognition_dropped"] = mod_stats["pattern_recognition_dropped"]
 
     new_tensors: Dict[str, torch.Tensor] = {}
     counts: Dict[str, int] = {"int8": 0, "int16": 0, "int32": 0, "int64": 0,

variants/neural_alu16.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:bbdd1fa4da68c78c6df075b1348ccdc6078f32c00cab4fbf5a637268d057948f
-size 17045126
+oid sha256:e4bb673798d1e81b4717907d1b352e72e084c31bc7e29a4a7d57a976234ee5f2
+size 20543560

variants/neural_alu32.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5e1d73f1fb7c08476cfe33b4af7a23abce2e1dcb320166d503f41f90fb80fe66
-size 18610419
+oid sha256:e00da59527751140f4ab49cb23c08625f42ff2dd58edfc986d8227beb0861ef7
+size 19144181

variants/neural_alu8.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ef6eeadc02e7791c0172fdd747be6069cee9d42f7a0117ec790a5c82446aca52
-size 15476531
+oid sha256:cf695c9047ff59cc0aed1b541f49b22d0820f474d38790496b9118551393c628
+size 18974877

variants/neural_computer16.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7b1a4769cc97b531f240b30a1be6c3d586705162ba092d15faf36d625553e712
-size 25545780
+oid sha256:d3aba5acdd2e5c177e3517f75a3e2adbc24873e1152d9e588ae8a542a2b14e2b
+size 29055270

variants/neural_computer16_reduced.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a4898c06100b2d9cb2a6281899f97545d8d9d1026dcde12ee0e9e53a9aec83a0
-size 17734524
+oid sha256:f1c8de07c243b19cd997dcedddf6b9e916d1ac316c8e468d5538b0eda7f7d3c9
+size 21244574

variants/neural_computer16_registers.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0caa9087e34b1b3463d8ea17e22fc1ce2786f1d121e1a4b7ee19024f99560536
-size 17131660
+oid sha256:97918a5d3239178a7568a96b4e895bbd29feb8e3e41726baff62bacf00a1e5de
+size 20630294

variants/neural_computer16_scratchpad.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a33d563bf442171a7cd543e91dee4f59e550470a785b3abd7fc87642c5244b84
-size 17212388
+oid sha256:05d26708a1ae548a6e46d73e444022af911dfe8bba43313dddf135be6f2ee618
+size 20710790

variants/neural_computer16_small.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1450a242b5f35da0e07ff9d7cfea656dc819318bdb1b0c1b92eeb874be063a4b
-size 17331228
+oid sha256:7185ef10e5639e7cce6f5a91dc604872c4bb4740be6f1125a71b981225bcf3ad
+size 20829606

variants/neural_computer32.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5ac52a81ce84db5c223619377dc371ee8585e398638d27005e3beae9920a14cc
-size 27129497
+oid sha256:a4333d8f1ea13945e129711733b7f79e96a9d876f40342db1e1634fdd2d85056
+size 27674339

variants/neural_computer32_reduced.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:bede692b9066b5da2f4323a1f9524a03d3aaebe44426e17d8a4b6b40b293665b
-size 19318801
+oid sha256:3521e0322363c3d55966810bda3efbf11ba0dd338f94ddee3128e15df6f05fa1
+size 19863635

variants/neural_computer32_registers.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4c069defbe8983c9706f73e7e1ba30a1957ce637a518eeaa21f2f453004653ca
-size 18715553
+oid sha256:bebf86dc5d383c10f069127d2dd10a045590c401df8d61fd8b160e4cb7dfc0d8
+size 19249315

variants/neural_computer32_scratchpad.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:feb88c8ca6882d45c9ea3ad0fe447a63c95e98cbefc3f1955c43ac1c09c4d323
-size 18796065
+oid sha256:fc140be67469b1eea6080081a3ed413a4a7f995fcf0db98bc16a885561b1b7cf
+size 19329827

variants/neural_computer32_small.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b53f4b57f99409cf2204e4ddaeec05eb381b1ef6091808f4a2462f5575d1e4fa
-size 18914905
+oid sha256:1a5f9964c7c6470495a1982ebfe60f8ba76a60f18fd9a84fedbdefc52f619963
+size 19448667

variants/neural_computer8.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ebe7336a5853e445ee490472570febf874a5c9795cd1e3aa6bc82615ab10647a
-size 23967977
+oid sha256:f6f90ec62fa9b95de0740b4532872cf287986636f0ae53f2d8681ab4bbd4250b
+size 27477411

variants/neural_computer8_reduced.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:323e44b6d218fee6ece8ef8792482cd55556ab0b9a6dc08cef3dbce33aaee176
-size 16156705
+oid sha256:b4d6c5f20b3f292ca725e4b0101b83d351b6018a82884b4283b648acddc0d7aa
+size 19666683

variants/neural_computer8_registers.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:14788684708414276ecde83ea2f7ed549dfe21acad90e46947274f3ff6e02253
-size 15553977
+oid sha256:7ecced984c18842e8b69e57dfc4e033780f6f1d72af8df33bffa784d648e0168
+size 19052491

variants/neural_computer8_scratchpad.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1431ce552517ff3df400d8c98eab7cda8b0bd951e8154e3b47bfdee1be2b70f8
-size 15634545
+oid sha256:945d2e44f7527dc71342baf80402ae6c538d5ae5ec0a65107ebe9bc560f4794e
+size 19133083

variants/neural_computer8_small.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:3d55a3bd459591aeb7ccd4cd9a0f11bc69a5db602c604b85661e1657657dba68
-size 15753409
+oid sha256:6b6f18efce73b5c4df27e8e60928a971a717374905b3036fff7ae5158af53271
+size 19251795