Upload README.md with huggingface_hub

README.md

@@ -1,359 +1,163 @@
----
-license: mit
-tags:
-- threshold-logic
-- neuromorphic
-- computer-architecture
-- formal-verification
-- coq
-- turing-complete
-- loihi
-- truenorth
-- akida
+# 8bit-threshold-computer-10166
+
+**A Turing-complete 8-bit CPU implemented as threshold logic gates.**
+
+This is the original, uncompressed model containing 10,166 bits of information.
+
+```
+Parameters: 2,392
+Unique Weights: 19
+Information: 10,166 bits
+```
+
 ---
 
-# 8bit-threshold-computer
+## Naming Convention
 
-A complete **Turing-complete 8-bit computer** implemented entirely in threshold logic neurons. No traditional logic gates - every operation uses weighted sums with Heaviside step activation.
+The number in the repo name represents the **information content in bits**:
 
-**Tested**: Rock-Paper-Scissors, FizzBuzz, countdown loops, and ALU operations all execute correctly using only threshold neuron computations.
+```
+Bits = Parameters × log₂(Unique Weights)
+     = 2,392 × log₂(19)
+     = 2,392 × 4.25
+     = 10,166 bits
+```
+
+This naming scheme allows direct comparison of model complexity across the family:
 
-## System Architecture
+| Model | Parameters | Unique Weights | Bits | Compression |
+|-------|------------|----------------|------|-------------|
+| **8bit-threshold-computer-10166** | 2,392 | 19 | **10,166** | Original |
+| [8bit-threshold-computer-1640](https://huggingface.co/phanerozoic/8bit-threshold-computer-1640) | 386 | 19 | 1,640 | Pattern deduplication |
+| [8bit-threshold-computer-772](https://huggingface.co/phanerozoic/8bit-threshold-computer-772) | 386 | 4 | 772 | Evolutionary minimization |
+
+Lower bits = more compressed = same computation in less information.
+
+---
+
+## What Is This?
+
+A complete 8-bit processor where every logic gate is implemented as a threshold neuron:
+
+```
+output = 1  if  (Σ wᵢxᵢ + b) ≥ 0
+         0  otherwise
+```
 
 | Component | Specification |
 |-----------|---------------|
-| Registers | 4 x 8-bit (R0, R1, R2, R3) |
-| Memory | 256 bytes |
-| Program Counter | 8-bit |
-| Instruction Width | 16-bit |
-| ALU Operations | 16 |
-| Status Flags | Z (Zero), N (Negative), C (Carry), V (Overflow) |
-| **Total Circuits** | **93** |
-| **Total Tensors** | **1,193** |
-| **Total Parameters** | **2,386** |
-
-## Quick Start
-
-```python
-import torch
-from safetensors.torch import load_file
+| Registers | 4 × 8-bit general purpose |
+| Memory | 256 bytes addressable |
+| ALU | 16 operations (ADD, SUB, AND, OR, XOR, NOT, SHL, SHR, INC, DEC, CMP, NEG, PASS, ZERO, ONES, NOP) |
+| Flags | Zero, Negative, Carry, Overflow |
+| Control | JMP, JZ, JNZ, JC, JNC, JN, JP, JV, JNV, CALL, RET, PUSH, POP |
 
-weights = load_file("neural_computer.safetensors")
+**Turing complete.** Verified against 95 programs including loops, recursion, and self-modification.
 
-def heaviside(x):
-    """Threshold activation: fires if x >= 0"""
-    return (x >= 0).int()
+---
 
-def threshold_neuron(inputs, weight, bias):
-    """Single threshold neuron computation"""
-    weighted_sum = (inputs.float() * weight.float()).sum() + bias.float()
-    return heaviside(weighted_sum)
+## Model Structure
 
-# Example: AND gate
-and_w = weights['boolean.and.weight']  # [1.0, 1.0]
-and_b = weights['boolean.and.bias']    # [-2.0]
+This model stores each circuit component as a separate tensor:
 
-for a in [0, 1]:
-    for b in [0, 1]:
-        result = threshold_neuron(torch.tensor([a, b]), and_w, and_b)
-        print(f"AND({a}, {b}) = {result.item()}")
-```
+| Metric | Value |
+|--------|-------|
+| Total tensors | 1,194 |
+| Total parameters | 2,392 |
+| Unique weight values | 19 |
+| File size | 119,960 bytes (~120 KB) |
 
-## Instruction Set
-
-### ALU Operations (Opcodes 0-15)
-
-| Op | Mnemonic | Operation | Opcode |
-|----|----------|-----------|--------|
-| 0 | ADD | dest = src1 + src2 | 0000 |
-| 1 | SUB | dest = src1 - src2 | 0001 |
-| 2 | AND | dest = src1 & src2 | 0010 |
-| 3 | OR | dest = src1 \| src2 | 0011 |
-| 4 | XOR | dest = src1 ^ src2 | 0100 |
-| 5 | NOT | dest = ~src1 | 0101 |
-| 6 | SHL | dest = src1 << 1 | 0110 |
-| 7 | SHR | dest = src1 >> 1 | 0111 |
-| 8 | INC | dest = src1 + 1 | 1000 |
-| 9 | DEC | dest = src1 - 1 | 1001 |
-| 10 | CMP | flags = src1 - src2 | 1010 |
-| 11 | NEG | dest = -src1 | 1011 |
-| 12 | PASS | dest = src1 | 1100 |
-| 13 | ZERO | dest = 0 | 1101 |
-| 14 | ONES | dest = 0xFF | 1110 |
-| 15 | NOP | no operation | 1111 |
-
-### Control Flow
-
-| Cond | Mnemonic | Condition |
-|------|----------|-----------|
-| 0 | JMP | unconditional |
-| 1 | JZ | Z = 1 (zero) |
-| 2 | JNZ | Z = 0 (not zero) |
-| 3 | JC | C = 1 (carry) |
-| 4 | JNC | C = 0 (no carry) |
-| 5 | JN | N = 1 (negative) |
-| 6 | JP | N = 0 (positive) |
-| 7 | JV | V = 1 (overflow) |
-
-### Stack & Memory
-
-| Mnemonic | Operation |
-|----------|-----------|
-| LD | Load from memory |
-| ST | Store to memory |
-| PUSH | Push to stack |
-| POP | Pop from stack |
-| CALL | Call subroutine |
-| RET | Return from subroutine |
-
-## Complete Circuit Inventory
-
-### ALU (3 circuits, 305 params)
-
-| Circuit | Tensors | Parameters | Description |
-|---------|---------|------------|-------------|
-| alu8bit | 17 | 201 | Complete 8-bit ALU with 16 operations |
-| alucontrol | 32 | 80 | 4-bit opcode decoder |
-| aluflags | 8 | 24 | Z, N, C, V flag computation |
-
-### Boolean (9 circuits, 44 params)
-
-| Circuit | Tensors | Parameters | Weights | Bias |
-|---------|---------|------------|---------|------|
-| and | 2 | 3 | [1, 1] | -2 |
-| or | 2 | 3 | [1, 1] | -1 |
-| not | 2 | 2 | [-1] | 0 |
-| nand | 2 | 3 | [-1, -1] | 1 |
-| nor | 2 | 3 | [-1, -1] | 0 |
-| xor | 6 | 9 | 2-layer network |
-| xnor | 6 | 9 | 2-layer network |
-| implies | 2 | 3 | [-1, 1] | 0 |
-| biimplies | 6 | 9 | 2-layer network |
-
-### Arithmetic (16 circuits, 612 params)
-
-| Circuit | Tensors | Parameters | Description |
-|---------|---------|------------|-------------|
-| halfadder | 8 | 12 | 1-bit half adder |
-| fulladder | 18 | 27 | 1-bit full adder |
-| ripplecarry2bit | 36 | 54 | 2-bit ripple carry adder |
-| ripplecarry4bit | 72 | 108 | 4-bit ripple carry adder |
-| ripplecarry8bit | 144 | 216 | 8-bit ripple carry adder |
-| incrementer8bit | 2 | 16 | 8-bit increment |
-| decrementer8bit | 2 | 16 | 8-bit decrement |
-| equality8bit | 50 | 81 | 8-bit equality comparison |
-| greaterthan8bit | 1 | 8 | 8-bit greater than |
-| greaterorequal8bit | 1 | 8 | 8-bit greater or equal |
-| lessthan8bit | 1 | 8 | 8-bit less than |
-| lessorequal8bit | 1 | 8 | 8-bit less or equal |
-| absolutedifference8bit | 1 | 16 | 8-bit absolute difference |
-| max8bit | 1 | 16 | 8-bit maximum |
-| min8bit | 1 | 16 | 8-bit minimum |
-| multiplier2x2 | 8 | 12 | 2x2 bit multiplier |
-
-### Combinational (10 circuits, 119 params)
-
-| Circuit | Tensors | Parameters | Description |
-|---------|---------|------------|-------------|
-| multiplexer2to1 | 8 | 11 | 2:1 MUX |
-| multiplexer4to1 | 1 | 6 | 4:1 MUX |
-| multiplexer8to1 | 1 | 11 | 8:1 MUX |
-| demultiplexer1to2 | 4 | 6 | 1:2 DEMUX |
-| demultiplexer1to4 | 1 | 3 | 1:4 DEMUX |
-| demultiplexer1to8 | 1 | 4 | 1:8 DEMUX |
-| encoder8to3 | 6 | 27 | 8:3 priority encoder |
-| decoder3to8 | 16 | 32 | 3:8 decoder |
-| priorityencoder8bit | 1 | 8 | 8-bit priority encoder |
-| barrelshifter8bit | 1 | 11 | 8-bit barrel shifter |
-
-### Control (16 circuits, 806 params)
-
-| Circuit | Tensors | Parameters | Description |
-|---------|---------|------------|-------------|
-| jump | 16 | 16 | Unconditional jump |
-| jz | 64 | 88 | Jump if zero |
-| jnz | 64 | 88 | Jump if not zero |
-| jc | 64 | 88 | Jump if carry |
-| jnc | 64 | 88 | Jump if no carry |
-| jn | 64 | 88 | Jump if negative |
-| jp | 64 | 88 | Jump if positive |
-| jv | 64 | 88 | Jump if overflow |
-| jnv | 64 | 88 | Jump if no overflow |
-| conditionaljump | 64 | 88 | Generic conditional |
-| push | 2 | 2 | Push to stack |
-| pop | 2 | 2 | Pop from stack |
-| call | 2 | 2 | Call subroutine |
-| ret | 2 | 2 | Return |
-| sp_inc | 1 | 1 | Increment stack pointer |
-| sp_dec | 1 | 1 | Decrement stack pointer |
-
-### Error Detection (11 circuits, 116 params)
-
-| Circuit | Tensors | Parameters | Description |
-|---------|---------|------------|-------------|
-| paritychecker8bit | 2 | 9 | 8-bit parity checker |
-| paritygenerator8bit | 2 | 9 | 8-bit parity generator |
-| evenparitychecker | 2 | 9 | Even parity |
-| oddparitychecker | 4 | 11 | Odd parity |
-| checksum8bit | 2 | 9 | 8-bit checksum |
-| crc4 | 1 | 5 | CRC-4 |
-| crc8 | 1 | 9 | CRC-8 |
-| hammingencode4bit | 6 | 12 | Hamming(7,4) encoder |
-| hammingdecode7bit | 6 | 15 | Hamming(7,4) decoder |
-| hammingsyndrome | 3 | 12 | Hamming syndrome |
-| longitudinalparity | 2 | 16 | Longitudinal parity |
-
-### Modular Arithmetic (11 circuits, 99 params)
-
-| Circuit | Tensors | Parameters | Weights |
-|---------|---------|------------|---------|
-| mod2 | 2 | 9 | [1, -1, 1, -1, 1, -1, 1, -1] |
-| mod3 | 2 | 9 | [1, 1, -2, 1, 1, -2, 1, 1] |
-| mod4 | 2 | 9 | [1, 1, 1, -3, 1, 1, 1, -3] |
-| mod5 | 2 | 9 | [1, 1, 1, 1, -4, 1, 1, 1] |
-| mod6 | 2 | 9 | [1, 1, 1, 1, 1, -5, 1, 1] |
-| mod7 | 2 | 9 | [1, 1, 1, 1, 1, 1, -6, 1] |
-| mod8 | 2 | 9 | [1, 1, 1, 1, 1, 1, 1, -7] |
-| mod9 | 2 | 9 | [1, 1, 1, 1, 1, 1, 1, 1] |
-| mod10 | 2 | 9 | [1, 1, 1, 1, 1, 1, 1, 1] |
-| mod11 | 2 | 9 | [1, 1, 1, 1, 1, 1, 1, 1] |
-| mod12 | 2 | 9 | [1, 1, 1, 1, 1, 1, 1, 1] |
-
-### Pattern Recognition (10 circuits, 125 params)
-
-| Circuit | Tensors | Parameters | Description |
-|---------|---------|------------|-------------|
-| popcount | 2 | 9 | Population count (Hamming weight) |
-| allones | 2 | 9 | Detect all 1s |
-| allzeros | 2 | 9 | Detect all 0s |
-| alternating8bit | 2 | 16 | Detect alternating pattern |
-| hammingdistance8bit | 2 | 24 | Hamming distance |
-| leadingones | 1 | 8 | Count leading ones |
-| trailingones | 1 | 8 | Count trailing ones |
-| symmetry8bit | 6 | 13 | Detect palindrome pattern |
-| runlength | 1 | 8 | Run length encoding |
-| onehotdetector | 6 | 21 | Detect one-hot encoding |
-
-### Threshold (13 circuits, 117 params)
-
-| Circuit | Tensors | Parameters | Weights | Bias | Fires when |
-|---------|---------|------------|---------|------|------------|
-| oneoutof8 | 2 | 9 | [1,1,1,1,1,1,1,1] | -1 | >= 1 of 8 |
-| twooutof8 | 2 | 9 | [1,1,1,1,1,1,1,1] | -2 | >= 2 of 8 |
-| threeoutof8 | 2 | 9 | [1,1,1,1,1,1,1,1] | -3 | >= 3 of 8 |
-| fouroutof8 | 2 | 9 | [1,1,1,1,1,1,1,1] | -4 | >= 4 of 8 |
-| fiveoutof8 | 2 | 9 | [1,1,1,1,1,1,1,1] | -5 | >= 5 of 8 |
-| sixoutof8 | 2 | 9 | [1,1,1,1,1,1,1,1] | -6 | >= 6 of 8 |
-| sevenoutof8 | 2 | 9 | [1,1,1,1,1,1,1,1] | -7 | >= 7 of 8 |
-| alloutof8 | 2 | 9 | [1,1,1,1,1,1,1,1] | -8 | = 8 of 8 |
-| majority | 2 | 9 | [1,1,1,1,1,1,1,1] | -5 | > 50% |
-| minority | 2 | 9 | [-1,-1,-1,-1,-1,-1,-1,-1] | 3 | <= 37.5% |
-| atleastk_4 | 2 | 9 | [1,1,1,1,1,1,1,1] | -4 | >= k |
-| atmostk_4 | 2 | 9 | [-1,-1,-1,-1,-1,-1,-1,-1] | 4 | <= k |
-| exactlyk_4 | 6 | 21 | 2-layer network | | = k |
-
-## Example Programs
-
-### FizzBuzz
+### Weight Vocabulary
 
 ```python
-mod3_w = weights['modular.mod3.weight']  # [1, 1, -2, 1, 1, -2, 1, 1]
-mod5_w = weights['modular.mod5.weight']  # [1, 1, 1, 1, -4, 1, 1, 1]
-
-for n in range(1, 16):
-    bits = int_to_bits(n)
-    div3 = (weighted_sum(bits, mod3_w, 0) % 3) == 0
-    div5 = (weighted_sum(bits, mod5_w, 0) % 5) == 0
-
-    if div3 and div5: print("FizzBuzz")
-    elif div3: print("Fizz")
-    elif div5: print("Buzz")
-    else: print(n)
+[-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 8, 16, 32, 64, 128, 256]
 ```
 
-### Rock-Paper-Scissors
+These 19 values are sufficient to implement all Boolean logic and arithmetic circuits.
 
-```python
-def play_round(player, computer):
-    xor_result = alu_xor(player, computer)
-    if bits_to_int(xor_result) == 0:
-        return "Draw"
-    diff = alu_sub(player, computer)
-    return "Player wins" if (diff + 3) % 3 == 1 else "Computer wins"
-```
+---
 
-### Sum 1 to N
+## Circuit Categories
 
-```assembly
-    LDI R0, 0      ; sum = 0
-    LDI R1, 10     ; n = 10
-loop:
-    ADD R0, R0, R1 ; sum += n
-    DEC R1, R1     ; n--
-    JNZ loop       ; if n != 0, continue
-    ; Result: R0 = 55
-```
+The 1,194 tensors implement 93 distinct circuit types:
 
-### Fibonacci
-
-```assembly
-    LDI R0, 1      ; fib(n-2) = 1
-    LDI R1, 1      ; fib(n-1) = 1
-    LDI R2, 6      ; iterations
-loop:
-    ADD R3, R0, R1 ; fib(n) = fib(n-2) + fib(n-1)
-    MOV R0, R1
-    MOV R1, R3
-    DEC R2, R2
-    JNZ loop
-    ; Result: R1 = 21 (fib(8))
-```
+| Category | Circuits | Examples |
+|----------|----------|----------|
+| Boolean | 10 | AND, OR, NOT, NAND, NOR, XOR, XNOR, IMPLIES, BIIMPLIES |
+| Arithmetic | 18 | Half adder, full adder, 2/4/8-bit ripple carry, comparators |
+| ALU | 8 | 8-bit ADD, SUB, AND, OR, XOR, NOT, SHL, SHR + control |
+| Combinational | 12 | MUX (2:1, 4:1, 8:1), DEMUX, encoders, decoders, barrel shifter |
+| Control Flow | 15 | JMP, conditional jumps (8 types), CALL, RET, PUSH, POP |
+| Error Detection | 12 | Parity, checksum, CRC-4/8, Hamming encode/decode |
+| Threshold | 10 | k-of-n gates, majority, minority |
+| Pattern Recognition | 8 | Popcount, leading/trailing ones, symmetry detection |
 
-## Hardware Compatibility
+---
 
-All weights are integers. All activations are Heaviside step function. Designed for direct deployment on:
+## Files
 
-- **Intel Loihi** - Neuromorphic research chip
-- **IBM TrueNorth** - 1M neuron chip
-- **BrainChip Akida** - Edge neuromorphic processor
+| File | Description |
+|------|-------------|
+| `neural_computer.safetensors` | All 1,194 circuit tensors (120 KB) |
+| `turing_completeness_test.py` | Verification suite |
 
-## Verification
+---
 
-Circuit weights derived from axiom-free Coq proofs:
+## Usage
 
-1. **Exhaustive verification** - All inputs tested
-2. **Universal quantification** - Symbolic proofs over all boolean combinations
-3. **Algebraic characterization** - Weight patterns proven correct
+```python
+from safetensors.torch import load_file
 
-Full Coq proofs: [github.com/CharlesCNorton/coq-circuits](https://github.com/CharlesCNorton/coq-circuits)
+# Load model
+tensors = load_file("neural_computer.safetensors")
 
-## Tensor Naming Convention
+print(f"Tensors: {len(tensors)}")
+# Output: Tensors: 1194
 
+# Check weight vocabulary
+all_weights = set()
+for t in tensors.values():
+    all_weights.update(t.flatten().tolist())
+print(f"Unique weights: {len(all_weights)}")
+# Output: Unique weights: 19
 ```
-{category}.{circuit}.{layer}.{component}.{weight|bias}
-
-Examples:
-  boolean.and.weight
-  boolean.xor.layer1.or.weight
-  alu.alu8bit.xor.layer2.bias
-  control.jz.mux.bit0.weight
-  arithmetic.ripplecarry8bit.fa7.sum.layer1.or.weight
-```
+
+---
+
+## Compression Opportunity
+
+Many of the 1,194 tensors are **duplicates** — the same weight pattern reused across different circuits. This model can be compressed via:
+
+1. **Pattern deduplication** → [8bit-threshold-computer-1640](https://huggingface.co/phanerozoic/8bit-threshold-computer-1640)
+2. **Weight vocabulary minimization** → [8bit-threshold-computer-772](https://huggingface.co/phanerozoic/8bit-threshold-computer-772)
+
+---
 
 ## Citation
 
 ```bibtex
-@software{threshold_computer_2025,
-  title={8bit-threshold-computer: Turing-Complete Threshold Logic Computer},
-  author={Norton, Charles},
-  url={https://huggingface.co/phanerozoic/8bit-threshold-computer},
-  year={2025},
-  note={93 verified circuits, 2386 parameters}
+@misc{8bit-threshold-computer-10166,
+  title={8bit-threshold-computer-10166: A Threshold Logic CPU},
+  author={phanerozoic},
+  year={2026},
+  howpublished={Hugging Face},
+  url={https://huggingface.co/phanerozoic/8bit-threshold-computer-10166}
 }
 ```
 
-## Links
+---
+
+## License
+
+MIT
+
+---
+
+## See Also
+
+- [8bit-threshold-computer-1640](https://huggingface.co/phanerozoic/8bit-threshold-computer-1640) — Pattern-deduplicated (6.2× smaller)
+- [8bit-threshold-computer-772](https://huggingface.co/phanerozoic/8bit-threshold-computer-772) — Evolutionarily minimized (13.2× smaller)
+
+---
 
-- [GitHub Repository](https://github.com/CharlesCNorton/coq-circuits)
-- [Coq Proofs](https://github.com/CharlesCNorton/coq-circuits/tree/main/coq)
-- [Individual Circuit Models](https://huggingface.co/phanerozoic)
+*2,392 parameters. 19 weights. 10,166 bits. The original.*