Atomic Neural Transistors (ANTs)

Ultra-small (<5K param) composable neural primitives for real-time AI

What are ANTs?

ANTs are the transistors of neural computing - atomic units that perform single operations with high precision and compose into larger systems.

Just as silicon transistors:

• Do one thing (switch on/off)
• Compose into gates, then circuits, then CPUs
• Are fast and predictable

ANTs:

• Do one thing (compare, classify, diff, etc.)
• Compose into meshes, then bridges, then cognitive systems
• Run in microseconds with deterministic behavior

Pretrained Models

Quick Start

use atomic_neural_transistors::{AtomicNeuralTransistor, AtomicConfig};
use candle_core::{Device, DType};
use candle_nn::{VarBuilder, VarMap};

// Create a tiny ANT
let device = Device::Cpu;
let varmap = VarMap::new();
let vb = VarBuilder::from_varmap(&varmap, DType::F32, &device);

let ant = AtomicNeuralTransistor::new(&AtomicConfig::tiny(32, 1), vb)?;
println!("Parameters: {}", ant.param_count()); // ~1.5K

Composition Algebra

Complex operations compose from primitives without additional training:

use atomic_neural_transistors::composition::{contains, has_duplicate, PerfectEquality};

let checker = PerfectEquality;

// contains = OR(AreEqual(query, seq[i]) for all i)
assert!(contains(&checker, 5, &[1, 2, 3, 5, 7]));

// has_duplicate = OR(AreEqual(seq[i], seq[j]) for all i < j)
assert!(has_duplicate(&checker, &[1, 2, 3, 2, 5]));

Architecture

atomic-neural-transistors/
├── src/
│   ├── config/          # AtomicConfig
│   ├── core/            # AtomicNeuralTransistor (the fundamental ANT)
│   ├── ants/            # Specialized ANTs
│   │   ├── compare.rs   # CompareANT
│   │   ├── diff.rs      # DiffANT
│   │   ├── merge.rs     # MergeANT
│   │   ├── gate.rs      # GateANT
│   │   └── classifier.rs# ClassifierANT
│   ├── composition/     # Composition algebra
│   │   ├── sequence.rs  # contains, has_duplicate, etc.
│   │   └── grid.rs      # Grid operations
│   └── pretrained/      # Model loading
└── models/              # Pretrained weights

Specialized ANTs

Examples

# Basic ANT usage
cargo run --example basic_usage

# Composition algebra
cargo run --example composition

# Sudoku validation
cargo run --example sudoku_check

Why ANTs?

1. Specialization Beats Generalization

A 117M param model allocates capacity across all tasks. ANTs dedicate 100% of their capacity to one operation.

2. Composition Preserves Accuracy

Unlike end-to-end training where errors compound, ANT composition maintains component accuracy. If AreEqual achieves 99.5%, composed operations inherit this precision.

3. Edge Deployment

ANTs run on:

• Embedded systems
• Mobile devices
• Browsers (via WASM)
• Microcontrollers

License

MIT OR Apache-2.0

Citation

@software{ant2024,
  title={Atomic Neural Transistors},
  author={Blackfall Labs},
  year={2024},
  url={https://github.com/blackfall-labs/atomic-neural-transistors}
}