README.md

---
license: mit
tags:
- pytorch
- safetensors
- threshold-logic
- neuromorphic
- multi-layer
---

# threshold-biimplies

The biconditional: x ↔ y ("if and only if"). Functionally identical to XNOR, but framed as the logical equivalence relation.

## Circuit

```
      x       y
      │       │
      ├───┬───┤
      │   │   │
      ▼   │   ▼
  ┌──────┐│┌──────┐
  │ NOR  │││ AND  │   Layer 1
  │w:-1,-1││w:1,1 │
  │b: 0  │││b: -2 │
  └──────┘│└──────┘
      │   │   │
      └───┼───┘
          ▼
      ┌──────┐
      │  OR  │         Layer 2
      │w: 1,1│
      │b: -1 │
      └──────┘
          │
          ▼
       x ↔ y
```

## Mechanism

The biconditional tests whether x and y have the same truth value:

| x | y | NOR | AND | x ↔ y |
|---|---|-----|-----|-------|
| 0 | 0 | 1 | 0 | 1 |
| 0 | 1 | 0 | 0 | 0 |
| 1 | 0 | 0 | 0 | 0 |
| 1 | 1 | 0 | 1 | 1 |

NOR catches "both false," AND catches "both true," OR combines.

## Why Two Layers?

Unlike simple implication (x → y), the biconditional is not linearly separable. It requires detecting two diagonal cases - same problem as XOR.

Implication x → y can be computed with weights [-1, +1] because it fails only at (1,0). Biimplication fails at both (0,1) and (1,0) - these points cannot be separated from (0,0) and (1,1) by a single hyperplane.

## Parameters

| Layer | Weights | Bias |
|-------|---------|------|
| NOR | [-1, -1] | 0 |
| AND | [1, 1] | -2 |
| OR | [1, 1] | -1 |
| **Total** | | **9** |

## Properties

- Reflexive: x ↔ x = 1
- Symmetric: (x ↔ y) = (y ↔ x)
- Transitive: (x ↔ y) ∧ (y ↔ z) → (x ↔ z)

Full equivalence relation.

## Usage

```python
from safetensors.torch import load_file
import torch

w = load_file('model.safetensors')

def biimplies_gate(x, y):
    inp = torch.tensor([float(x), float(y)])

    nor_out = int((inp * w['layer1.neuron1.weight']).sum() + w['layer1.neuron1.bias'] >= 0)
    and_out = int((inp * w['layer1.neuron2.weight']).sum() + w['layer1.neuron2.bias'] >= 0)

    l1 = torch.tensor([float(nor_out), float(and_out)])
    return int((l1 * w['layer2.weight']).sum() + w['layer2.bias'] >= 0)
```

## Files

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

## License

MIT