threshold-exactly4outof8

Exactly-4-out-of-8 detector. Fires when precisely half the inputs are active. The tie detector.

Circuit

  x₀ x₁ x₂ x₃ x₄ x₅ x₆ x₇
   │  │  │  │  │  │  │  │
   └──┴──┴──┴──┼──┴──┴──┴──┘
               │
       ┌───────┴───────┐
       ▼               ▼
  ┌─────────┐     ┌─────────┐
  │  ≥ 4    │     │  ≤ 4    │
  │ b = -4  │     │ b = +4  │
  └─────────┘     └─────────┘
       │               │
       └───────┬───────┘
               ▼
          ┌─────────┐
          │   AND   │
          └─────────┘
               │
               ▼
            tie?

The Center of the Distribution

HW = 4 is special:

• Maximum entropy: C(8,4) = 70 is the largest binomial coefficient for n=8
• Perfect balance: 4 ones, 4 zeros
• Self-complementary: Flipping all bits maps HW=4 to itself (though not necessarily the same pattern)

This circuit fires on 70 of 256 inputs - the mode of the distribution.

Neither Majority Nor Minority

Circuit	Condition	Fires at HW=4?
Majority	HW ≥ 5	No
Minority	HW ≤ 3	No
Exactly4	HW = 4	Yes

Exactly4 catches what both Majority and Minority miss. It's the gap between them - the deadlock.

Threshold Arithmetic

AtLeast4: Sum all inputs with weight +1, subtract 4.

x₀ + x₁ + x₂ + x₃ + x₄ + x₅ + x₆ + x₇ - 4 ≥ 0

Fires when 4 or more inputs are active.

AtMost4: Sum all inputs with weight -1, add 4.

-x₀ - x₁ - x₂ - x₃ - x₄ - x₅ - x₆ - x₇ + 4 ≥ 0

Fires when 4 or fewer inputs are active.

Their intersection is exactly 4.

The Binomial Peak

HW	C(8,k)	Exactly4?
0	1	-
1	8	-
2	28	-
3	56	-
4	70	YES
5	56	-
6	28	-
7	8	-
8	1	-

The distribution is symmetric around 4. This circuit sits at the apex.

Parameters

Component	Weights	Bias
AtLeast4	all +1	-4
AtMost4	all -1	+4
AND	[+1, +1]	-2

Total: 3 neurons, 21 parameters, 2 layers

Usage

from safetensors.torch import load_file
import torch

w = load_file('model.safetensors')

def exactly4(bits):
    inp = torch.tensor([float(b) for b in bits])
    atleast = int((inp * w['atleast.weight']).sum() + w['atleast.bias'] >= 0)
    atmost = int((inp * w['atmost.weight']).sum() + w['atmost.bias'] >= 0)
    comb = torch.tensor([float(atleast), float(atmost)])
    return int((comb * w['and.weight']).sum() + w['and.bias'] >= 0)

# Balanced: alternating pattern
bits = [1, 0, 1, 0, 1, 0, 1, 0]
print(exactly4(bits))  # 1

# Majority (5) - not a tie
bits = [1, 1, 1, 0, 1, 0, 1, 0]
print(exactly4(bits))  # 0

Files

threshold-exactly4outof8/
├── model.safetensors
├── model.py
├── config.json
└── README.md

License

MIT