Upload folder using huggingface_hub

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -17,9 +17,8 @@ tags:
 Every logic gate is a threshold neuron: `output = 1 if (Σ wᵢxᵢ + b) ≥ 0 else 0`
 
 ```
-Tensors:    1,482
-Parameters: 3,188
-Tests:      4,416/4,416 passing
+Tensors:    3,122
+Parameters: 5,648
 ```
 
 ---
@@ -85,7 +84,7 @@ The model includes `iron_eval.py` which exhaustively tests all circuits:
 
 ```bash
 python iron_eval.py
-# Output: Fitness: 1.000000 (4416/4416 tests passing)
+# Output: Fitness: 1.000000 (4478 tests)
 ```
 
 ### Verification Status

iron_eval.py

@@ -13,7 +13,7 @@ from typing import Dict, Tuple
 from safetensors import safe_open
 
 
-def load_model_10166(base_path: str = "D:/8bit-threshold-computer-10166") -> Dict[str, torch.Tensor]:
+def load_model_10166(base_path: str = "D:/8bit-threshold-computer") -> Dict[str, torch.Tensor]:
     """Load model from safetensors."""
     f = safe_open(f"{base_path}/neural_computer.safetensors", framework='numpy')
     tensors = {}
@@ -315,6 +315,129 @@ class BatchedFitnessEvaluator:
 
         return scores
 
+    def _test_multiplier8x8(self, pop: Dict, debug: bool = False) -> torch.Tensor:
+        """Test 8x8 array multiplier."""
+        pop_size = next(iter(pop.values())).shape[0]
+        scores = torch.zeros(pop_size, device=self.device)
+        failures = []
+
+        test_pairs = [
+            (0, 0), (1, 1), (2, 3), (3, 2), (7, 7), (8, 8),
+            (15, 15), (16, 16), (255, 1), (1, 255), (255, 255),
+            (12, 12), (10, 25), (17, 15), (128, 2), (64, 4),
+            (0, 255), (255, 0), (100, 100), (50, 200), (200, 50),
+            (127, 127), (128, 128), (85, 3), (170, 2), (99, 99),
+            (13, 17), (23, 29), (31, 33), (41, 43), (53, 59),
+            (61, 67), (71, 73), (79, 83), (89, 97), (101, 103),
+            (107, 109), (113, 127), (131, 137), (139, 149), (151, 157),
+            (163, 167), (173, 179), (181, 191), (193, 197), (199, 211),
+            (223, 227), (229, 233), (239, 241), (251, 1), (1, 251),
+            (2, 128), (4, 64), (8, 32), (32, 8),
+            (3, 85), (5, 51), (7, 36),
+            (9, 28), (11, 23), (13, 19), (15, 17)
+        ]
+
+        for a_val, b_val in test_pairs:
+            expected = (a_val * b_val) & 0xFFFF
+
+            a_bits = [(a_val >> i) & 1 for i in range(8)]
+            b_bits = [(b_val >> i) & 1 for i in range(8)]
+
+            pp = [[torch.zeros(pop_size, device=self.device) for _ in range(8)] for _ in range(8)]
+            for row in range(8):
+                for col in range(8):
+                    a_t = torch.full((pop_size,), float(a_bits[col]), device=self.device)
+                    b_t = torch.full((pop_size,), float(b_bits[row]), device=self.device)
+                    inp = torch.stack([a_t, b_t], dim=1)
+                    w = pop[f'arithmetic.multiplier8x8.pp.r{row}.c{col}.weight'].view(pop_size, -1)
+                    b = pop[f'arithmetic.multiplier8x8.pp.r{row}.c{col}.bias'].view(pop_size)
+                    pp[row][col] = heaviside((inp * w).sum(1) + b)
+
+            result_bits = [torch.zeros(pop_size, device=self.device) for _ in range(16)]
+            for col in range(8):
+                result_bits[col] = pp[0][col]
+
+            for stage in range(7):
+                row_idx = stage + 1
+                shift = row_idx
+                sum_width = 8 + stage + 1
+
+                new_result = [r.clone() for r in result_bits]
+                carry = torch.zeros(pop_size, device=self.device)
+
+                for bit in range(sum_width):
+                    if bit < shift:
+                        pp_bit = torch.zeros(pop_size, device=self.device)
+                    elif bit <= shift + 7:
+                        pp_bit = pp[row_idx][bit - shift]
+                    else:
+                        pp_bit = torch.zeros(pop_size, device=self.device)
+
+                    prev_bit = result_bits[bit] if bit < 16 else torch.zeros(pop_size, device=self.device)
+
+                    prefix = f'arithmetic.multiplier8x8.stage{stage}.bit{bit}'
+
+                    inp_ab = torch.stack([prev_bit, pp_bit], dim=1)
+                    w1_or = pop[f'{prefix}.ha1.sum.layer1.or.weight'].view(pop_size, -1)
+                    b1_or = pop[f'{prefix}.ha1.sum.layer1.or.bias'].view(pop_size)
+                    w1_nand = pop[f'{prefix}.ha1.sum.layer1.nand.weight'].view(pop_size, -1)
+                    b1_nand = pop[f'{prefix}.ha1.sum.layer1.nand.bias'].view(pop_size)
+                    w1_l2 = pop[f'{prefix}.ha1.sum.layer2.weight'].view(pop_size, -1)
+                    b1_l2 = pop[f'{prefix}.ha1.sum.layer2.bias'].view(pop_size)
+
+                    h_or = heaviside((inp_ab * w1_or).sum(1) + b1_or)
+                    h_nand = heaviside((inp_ab * w1_nand).sum(1) + b1_nand)
+                    hidden1 = torch.stack([h_or, h_nand], dim=1)
+                    ha1_sum = heaviside((hidden1 * w1_l2).sum(1) + b1_l2)
+
+                    w_c1 = pop[f'{prefix}.ha1.carry.weight'].view(pop_size, -1)
+                    b_c1 = pop[f'{prefix}.ha1.carry.bias'].view(pop_size)
+                    ha1_carry = heaviside((inp_ab * w_c1).sum(1) + b_c1)
+
+                    inp_ha2 = torch.stack([ha1_sum, carry], dim=1)
+                    w2_or = pop[f'{prefix}.ha2.sum.layer1.or.weight'].view(pop_size, -1)
+                    b2_or = pop[f'{prefix}.ha2.sum.layer1.or.bias'].view(pop_size)
+                    w2_nand = pop[f'{prefix}.ha2.sum.layer1.nand.weight'].view(pop_size, -1)
+                    b2_nand = pop[f'{prefix}.ha2.sum.layer1.nand.bias'].view(pop_size)
+                    w2_l2 = pop[f'{prefix}.ha2.sum.layer2.weight'].view(pop_size, -1)
+                    b2_l2 = pop[f'{prefix}.ha2.sum.layer2.bias'].view(pop_size)
+
+                    h2_or = heaviside((inp_ha2 * w2_or).sum(1) + b2_or)
+                    h2_nand = heaviside((inp_ha2 * w2_nand).sum(1) + b2_nand)
+                    hidden2 = torch.stack([h2_or, h2_nand], dim=1)
+                    ha2_sum = heaviside((hidden2 * w2_l2).sum(1) + b2_l2)
+
+                    w_c2 = pop[f'{prefix}.ha2.carry.weight'].view(pop_size, -1)
+                    b_c2 = pop[f'{prefix}.ha2.carry.bias'].view(pop_size)
+                    ha2_carry = heaviside((inp_ha2 * w_c2).sum(1) + b_c2)
+
+                    inp_cout = torch.stack([ha1_carry, ha2_carry], dim=1)
+                    w_cor = pop[f'{prefix}.carry_or.weight'].view(pop_size, -1)
+                    b_cor = pop[f'{prefix}.carry_or.bias'].view(pop_size)
+                    carry = heaviside((inp_cout * w_cor).sum(1) + b_cor)
+
+                    if bit < 16:
+                        new_result[bit] = ha2_sum
+
+                # Propagate carry to next bit position if within range
+                if sum_width < 16:
+                    new_result[sum_width] = carry
+
+                result_bits = new_result
+
+            result = sum(result_bits[i] * (2**i) for i in range(16))
+            passed = (result == expected).float()
+            scores += passed
+            if debug and pop_size == 1 and passed[0].item() == 0:
+                failures.append(f"MULT({a_val} * {b_val}) = {int(result[0].item())}, expected {expected}")
+
+        if debug and failures:
+            print(f"\n  Multiplier failures ({len(failures)}):")
+            for f in failures:
+                print(f"    {f}")
+
+        return scores
+
     # =========================================================================
     # ARITHMETIC - COMPARATORS
     # =========================================================================
@@ -786,18 +909,22 @@ class BatchedFitnessEvaluator:
     # MAIN EVALUATE
     # =========================================================================
 
-    def evaluate(self, population: Dict[str, torch.Tensor]) -> torch.Tensor:
+    def evaluate(self, population: Dict[str, torch.Tensor], debug: bool = False) -> torch.Tensor:
         """Evaluate fitness for entire population."""
         pop_size = next(iter(population.values())).shape[0]
         scores = torch.zeros(pop_size, device=self.device)
         total_tests = 0
+        self.category_scores = {}  # Track per-category scores for debugging
 
         # =================================================================
         # BOOLEAN GATES (34 tests)
         # =================================================================
+        cat_start = scores.clone()
+        cat_tests = 0
         for gate in ['and', 'or', 'nand', 'nor']:
             scores += self._test_single_gate(population, gate, self.tt2, self.expected[gate])
             total_tests += 4
+            cat_tests += 4
 
         # NOT
         w = population['boolean.not.weight'].view(pop_size, -1)
@@ -805,111 +932,182 @@ class BatchedFitnessEvaluator:
         out = heaviside(self.not_inputs @ w.T + b)
         scores += (out == self.expected['not'].unsqueeze(1)).float().sum(0)
         total_tests += 2
+        cat_tests += 2
 
         # IMPLIES
         scores += self._test_single_gate(population, 'implies', self.tt2, self.expected['implies'])
         total_tests += 4
+        cat_tests += 4
 
         # XOR, XNOR, BIIMPLIES
         scores += self._test_twolayer_gate(population, 'boolean.xor', self.tt2, self.expected['xor'])
         scores += self._test_twolayer_gate(population, 'boolean.xnor', self.tt2, self.expected['xnor'])
         scores += self._test_twolayer_gate(population, 'boolean.biimplies', self.tt2, self.expected['biimplies'])
         total_tests += 12
+        cat_tests += 12
+        self.category_scores['boolean'] = ((scores - cat_start)[0].item(), cat_tests)
 
         # =================================================================
-        # ARITHMETIC - ADDERS (340 tests)
+        # ARITHMETIC - ADDERS (370 tests)
         # =================================================================
+        cat_start = scores.clone()
+        cat_tests = 0
+
+        sub_start = scores.clone()
         scores += self._test_halfadder(population)
         total_tests += 8
+        cat_tests += 8
+        self.category_scores['halfadder'] = ((scores - sub_start)[0].item(), 8)
 
+        sub_start = scores.clone()
         scores += self._test_fulladder(population)
         total_tests += 16
+        cat_tests += 16
+        self.category_scores['fulladder'] = ((scores - sub_start)[0].item(), 16)
 
         # Ripple carry adders
+        sub_start = scores.clone()
         rc2_tests = [(a, b) for a in range(4) for b in range(4)]
         scores += self._test_ripplecarry(population, 2, rc2_tests)
         total_tests += 16
+        cat_tests += 16
+        self.category_scores['ripplecarry2'] = ((scores - sub_start)[0].item(), 16)
 
+        sub_start = scores.clone()
         rc4_tests = [(a, b) for a in range(16) for b in range(16)]
         scores += self._test_ripplecarry(population, 4, rc4_tests)
         total_tests += 256
+        cat_tests += 256
+        self.category_scores['ripplecarry4'] = ((scores - sub_start)[0].item(), 256)
 
+        sub_start = scores.clone()
         rc8_tests = [(0,0), (1,1), (127,128), (255,1), (128,127), (255,255),
                      (0xAA, 0x55), (0x0F, 0xF0), (100, 155), (200, 55)]
         scores += self._test_ripplecarry(population, 8, rc8_tests)
         total_tests += len(rc8_tests)
+        cat_tests += len(rc8_tests)
+        self.category_scores['ripplecarry8'] = ((scores - sub_start)[0].item(), len(rc8_tests))
+
+        # 8x8 Multiplier (62 unique test pairs)
+        sub_start = scores.clone()
+        scores += self._test_multiplier8x8(population, debug=debug)
+        total_tests += 62
+        cat_tests += 62
+        self.category_scores['multiplier8x8'] = ((scores - sub_start)[0].item(), 62)
+
+        self.category_scores['arithmetic_adders'] = ((scores - cat_start)[0].item(), cat_tests)
 
         # =================================================================
-        # ARITHMETIC - COMPARATORS (240 tests)
+        # ARITHMETIC - COMPARATORS (300 tests)
         # =================================================================
+        cat_start = scores.clone()
+        cat_tests = 0
         scores += self._test_comparator(population, 'greaterthan8bit', 'gt')
         scores += self._test_comparator(population, 'lessthan8bit', 'lt')
         scores += self._test_comparator(population, 'greaterorequal8bit', 'geq')
         scores += self._test_comparator(population, 'lessorequal8bit', 'leq')
         total_tests += 4 * len(self.comp_a)
+        cat_tests += 4 * len(self.comp_a)
 
         scores += self._test_equality(population)
         total_tests += len(self.comp_a)
+        cat_tests += len(self.comp_a)
+        self.category_scores['comparators'] = ((scores - cat_start)[0].item(), cat_tests)
 
         # =================================================================
-        # THRESHOLD GATES (264 tests)
+        # THRESHOLD GATES (312 tests)
         # =================================================================
+        cat_start = scores.clone()
+        cat_tests = 0
         for k, name in enumerate(['oneoutof8', 'twooutof8', 'threeoutof8', 'fouroutof8',
                                    'fiveoutof8', 'sixoutof8', 'sevenoutof8', 'alloutof8'], 1):
             scores += self._test_threshold_kofn(population, k, name)
             total_tests += len(self.test_8bit)
+            cat_tests += len(self.test_8bit)
 
         scores += self._test_majority(population)
         scores += self._test_minority(population)
         total_tests += 2 * len(self.test_8bit)
+        cat_tests += 2 * len(self.test_8bit)
 
         scores += self._test_atleastk(population, 4)
         scores += self._test_atmostk(population, 4)
         scores += self._test_exactlyk(population, 4)
         total_tests += 3 * len(self.test_8bit)
+        cat_tests += 3 * len(self.test_8bit)
+        self.category_scores['threshold'] = ((scores - cat_start)[0].item(), cat_tests)
 
         # =================================================================
         # PATTERN RECOGNITION (72 tests)
         # =================================================================
+        cat_start = scores.clone()
+        cat_tests = 0
         scores += self._test_popcount(population)
         scores += self._test_allzeros(population)
         scores += self._test_allones(population)
         total_tests += 3 * len(self.test_8bit)
+        cat_tests += 3 * len(self.test_8bit)
+        self.category_scores['pattern'] = ((scores - cat_start)[0].item(), cat_tests)
 
         # =================================================================
         # ERROR DETECTION (48 tests)
         # =================================================================
+        cat_start = scores.clone()
+        cat_tests = 0
         scores += self._test_parity(population, 'paritychecker8bit', True)
         scores += self._test_parity(population, 'paritygenerator8bit', True)
         total_tests += 2 * len(self.test_8bit)
+        cat_tests += 2 * len(self.test_8bit)
+        self.category_scores['error_detection'] = ((scores - cat_start)[0].item(), cat_tests)
 
         # =================================================================
         # MODULAR ARITHMETIC (2816 tests: 256 values × 11 moduli)
         # =================================================================
+        cat_start = scores.clone()
+        cat_tests = 0
         for mod in [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]:
             scores += self._test_modular(population, mod)
             total_tests += len(self.mod_test)
+            cat_tests += len(self.mod_test)
+        self.category_scores['modular'] = ((scores - cat_start)[0].item(), cat_tests)
 
         # =================================================================
-        # COMBINATIONAL (88 tests)
+        # COMBINATIONAL (96 tests)
         # =================================================================
+        cat_start = scores.clone()
+        cat_tests = 0
         scores += self._test_mux2to1(population)
         total_tests += 8
+        cat_tests += 8
 
         scores += self._test_decoder3to8(population)
         total_tests += 64
+        cat_tests += 64
 
         scores += self._test_encoder8to3(population)
         total_tests += 24
+        cat_tests += 24
+        self.category_scores['combinational'] = ((scores - cat_start)[0].item(), cat_tests)
 
         # =================================================================
-        # CONTROL FLOW (480 tests: 10 circuits × 6 cases × 8 bits)
+        # CONTROL FLOW (432 tests: 9 circuits × 6 cases × 8 bits)
         # =================================================================
+        cat_start = scores.clone()
+        cat_tests = 0
         for ctrl in ['conditionaljump', 'jz', 'jnz', 'jc', 'jnc', 'jn', 'jp', 'jv', 'jnv']:
             scores += self._test_conditional_jump(population, ctrl)
             total_tests += 6 * 8
+            cat_tests += 6 * 8
+        self.category_scores['control_flow'] = ((scores - cat_start)[0].item(), cat_tests)
 
         self.total_tests = total_tests
+
+        if debug and pop_size == 1:
+            print("\n=== DEBUG: Per-category results ===")
+            for cat, (got, expected) in self.category_scores.items():
+                status = "PASS" if got == expected else "FAIL"
+                print(f"  {cat}: {int(got)}/{expected} [{status}]")
+
         return scores / total_tests
 
 
@@ -943,7 +1141,7 @@ if __name__ == "__main__":
     print("\nRunning evaluation...")
     torch.cuda.synchronize()
     start = time.perf_counter()
-    fitness = evaluator.evaluate(pop)
+    fitness = evaluator.evaluate(pop, debug=True)
     torch.cuda.synchronize()
     elapsed = time.perf_counter() - start
 

neural_computer.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:3c843f449639750f270702f5d5600d063c8e7d28f4a234fe062d3fcd8caf644b
-size 151728
+oid sha256:51d4e2725c0d24bce807a5b7dc58319e9eed0f95c17fc39e662272ed0cbe8f1f
+size 351104