FluxEM

Deterministic embeddings where algebraic operations become vector operations.

encode(a) + encode(b) = encode(a + b)

No training. No weights. Structure by construction.

→ Project page · The Vision

Quick Start

pip install fluxem

from fluxem import create_unified_model

model = create_unified_model()
model.compute("12345 + 67890")  # → 80235.0
model.compute("144 * 89")       # → 12816.0
model.compute("10 m/s * 5 s")   # → 50.0 m

What This Is

FluxEM encodes typed domain values into fixed-dimensional vectors where selected operations map to linear algebra:

• Addition/subtraction: encode(a) + encode(b) = encode(a + b)
• Multiplication/division: log_encode(a) + log_encode(b) = log_encode(a × b)

This extends across eleven domains—each with encoders that preserve algebraic structure.

What This Is Not

• Not symbolic math. Won't simplify x + x → 2x. Use SymPy for that.
• Not semantic embeddings. Won't find "king − man + woman ≈ queen". Use text embeddings.
• Not learned. No parameters, no training, no drift.

Domain Examples

Polynomials as Vectors

Adding two embedding vectors is equivalent to adding the polynomials they represent:

from fluxem.domains.math import PolynomialEncoder

enc = PolynomialEncoder(degree=2)

# P1: 3x² + 2x + 1
# P2:       x - 1
vec1 = enc.encode([3, 2, 1])
vec2 = enc.encode([0, 1, -1])

# The vector sum IS the polynomial sum
sum_vec = vec1 + vec2
print(enc.decode(sum_vec))
# → [3, 3, 0]  (which is 3x² + 3x)

Music: Harmony as Geometry

In pitch-class set theory, transposition is vector addition:

from fluxem.domains.music import ChordEncoder

enc = ChordEncoder()

# Encode a C Major chord
c_major = enc.encode("C", quality="major")

# Transpose by adding to the vector
f_major = enc.transpose(c_major, 5)  # Up 5 semitones

root, quality, _ = enc.decode(f_major)
print(f"{root} {quality}")
# → "F major"

Logic: Tautologies by Construction

Propositional logic encoded such that valid formulas occupy specific subspaces:

from fluxem.domains.logic import PropositionalEncoder, PropFormula

p = PropFormula.atom('p')
q = PropFormula.atom('q')

enc = PropositionalEncoder()
formula_vec = enc.encode(p.implies(q) | ~p)

print(enc.is_tautology(formula_vec))
# → True

C major: {0, 4, 7}  intervals: 4, then 3
C minor: {0, 3, 7}  intervals: 3, then 4

Reproducibility

git clone https://github.com/Hmbown/FluxEM.git && cd FluxEM
pip install -e ".[jax]"
python experiments/scripts/compare_embeddings.py

Outputs TSV tables comparing FluxEM to baselines:

table=accuracy_by_encoder
approach              dataset          exact_match    numeric_accuracy
FluxEM                id               1.000000       1.000000
FluxEM                ood_magnitude    1.000000       1.000000
Character             ood_magnitude    0.000000       0.012000

Installation

pip install fluxem              # Core (NumPy)
pip install fluxem[jax]         # With JAX
pip install fluxem[mlx]         # With MLX (Apple Silicon)
pip install fluxem[full-jax]    # Full with HuggingFace

Precision

Edge cases: log(0) → masked, division by zero → signed infinity, negative base with fractional exponent → unsupported.

See ERROR_MODEL.md and FORMAL_DEFINITION.md.

Related Work

Citation

@software{fluxem2026,
  title={FluxEM: Algebraic Embeddings for Deterministic Neural Computation},
  author={Bown, Hunter},
  year={2026},
  url={https://github.com/Hmbown/FluxEM}
}

License

MIT