threshold-binary-to-onehot

2-to-4 binary-to-one-hot encoder. Converts a 2-bit binary value to a 4-bit one-hot representation. The inverse of the one-hot decoder.

Circuit

     a1        a0
      │         │
      ├─────────┤
      │         │
  ┌───┴───┐ ┌───┴───┐
  │       │ │       │
  ▼       ▼ ▼       ▼
┌───┐   ┌───┐   ┌───┐   ┌───┐
│y0 │   │y1 │   │y2 │   │y3 │
│NOR│   │AND│   │AND│   │AND│
│   │   │¬a1│   │a1 │   │a1 │
│   │   │ a0│   │¬a0│   │a0 │
└───┘   └───┘   └───┘   └───┘
  │       │       │       │
  ▼       ▼       ▼       ▼
 y0      y1      y2      y3
(00)    (01)    (10)    (11)

Function

binary_to_onehot(a1, a0) -> (y0, y1, y2, y3)

Exactly one output is high, corresponding to the binary input value.

Truth Table

a1	a0	Value	y0	y1	y2	y3
0	0	0	1	0	0	0
0	1	1	0	1	0	0
1	0	2	0	0	1	0
1	1	3	0	0	0	1

Output encoding: y[i] = 1 iff input value equals i.

Mechanism

Each output neuron detects a specific binary pattern:

Output	Pattern	Weights [a1, a0]	Bias	Logic
y0	00	[-1, -1]	0	NOR(a1, a0)
y1	01	[-1, +1]	-1	¬a1 AND a0
y2	10	[+1, -1]	-1	a1 AND ¬a0
y3	11	[+1, +1]	-2	a1 AND a0

Analysis:

• y0 (value 0): Fires when both inputs are 0. Negative weights ensure any 1 prevents firing.
• y1 (value 1): Fires when a1=0 and a0=1. The -1 on a1 inhibits, +1 on a0 excites.
• y2 (value 2): Fires when a1=1 and a0=0. The +1 on a1 excites, -1 on a0 inhibits.
• y3 (value 3): Fires when both are 1. Both positive weights must overcome bias -2.

Architecture

Single-layer implementation with 4 parallel neurons:

Neuron	Weights	Bias	Detects
y0	[-1, -1]	0	Binary 00
y1	[-1, +1]	-1	Binary 01
y2	[+1, -1]	-1	Binary 10
y3	[+1, +1]	-2	Binary 11

Parameters

Inputs	2 (a1, a0)
Outputs	4 (y0, y1, y2, y3)
Neurons	4
Layers	1
Parameters	12
Magnitude	12

Relationship to One-Hot Decoder

This circuit is the inverse of threshold-onehot-decoder:

Binary [a1, a0] ──► binary-to-onehot ──► One-hot [y0, y1, y2, y3]
One-hot [y0, y1, y2, y3] ──► onehot-decoder ──► Binary [a1, a0]

Together they form a codec pair for binary ↔ one-hot conversion.

Usage

from safetensors.torch import load_file
import torch

w = load_file('model.safetensors')

def binary_to_onehot(a1, a0):
    inp = torch.tensor([float(a1), float(a0)])
    y0 = int((inp @ w['y0.weight'].T + w['y0.bias'] >= 0).item())
    y1 = int((inp @ w['y1.weight'].T + w['y1.bias'] >= 0).item())
    y2 = int((inp @ w['y2.weight'].T + w['y2.bias'] >= 0).item())
    y3 = int((inp @ w['y3.weight'].T + w['y3.bias'] >= 0).item())
    return y0, y1, y2, y3

# Examples
print(binary_to_onehot(0, 0))  # (1, 0, 0, 0) - value 0
print(binary_to_onehot(0, 1))  # (0, 1, 0, 0) - value 1
print(binary_to_onehot(1, 0))  # (0, 0, 1, 0) - value 2
print(binary_to_onehot(1, 1))  # (0, 0, 0, 1) - value 3

Applications

• Address decoding in memory systems
• Demultiplexer control signals
• State machine encoding
• Neural network softmax approximation
• Priority encoder inputs

Scaling

For n-bit binary to 2^n one-hot:

• 3-bit → 8 outputs (8 neurons)
• 4-bit → 16 outputs (16 neurons)

Each additional input bit doubles the outputs.

Files

threshold-binary-to-onehot/
├── model.safetensors
├── model.py
├── create_safetensors.py
├── config.json
└── README.md

License

MIT