Harmonic Field Compute:
Neural Networks as Continuous Gaussian Fields
with Metal Shader Acceleration

1. Introduction

The dominant paradigm in neural network design stores learned knowledge as dense weight matrices — rectangular arrays of floating-point numbers with no inherent structure. A single linear layer mapping 4,096 inputs to 16,384 outputs requires 67,108,864 individual parameters, consuming 268 MB at float32 precision. This representation is profligate: most entries encode smooth, structured functions that could be described far more compactly.

Post-hoc compression methods (quantization, pruning, distillation) treat this as a downstream optimization problem: train the dense model, then compress it. This approach has three fundamental limitations. First, the training process itself must allocate memory for the full dense model. Second, compression introduces approximation error that cannot be recovered. Third, the compressed representation is opaque — a quantized matrix is no more interpretable than the original.

We propose a different approach: never create the dense matrix at all. The Scalar Flux Tensor Transform (SFTT) represents each row of a weight matrix as a harmonic Gaussian mixture — a continuous function parameterized by a center (μ), spread (σ), harmonic shift (δ), and N harmonic weights. The total parameter count per row is 3+N, regardless of input dimension. For N=8, a layer mapping 4,096 to 16,384 requires 180,224 parameters instead of 67,108,864 — a 372× compression — and this representation is trained from scratch, not compressed after the fact.

The key mathematical insight enabling this framework is that Gaussian functions are algebraically closed under multiplication. Two Gaussians multiplied together produce another Gaussian with parameters that are simple functions of the inputs:

This closure property means that operations traditionally requiring matrix multiplication — layer composition, attention score computation, model merging — can be performed as parameter arithmetic on the harmonic fields. The dense matrix never needs to exist.

We implement this framework as 7 Metal compute shaders running on Apple silicon GPUs via torch.mps.compile_shader(), creating a complete training and inference pipeline that requires no NVIDIA hardware. The shaders operate directly on harmonic parameters, dispatching Gaussian evaluation across thousands of GPU threads.

2. Mathematical Framework

2.1 The Harmonic Gaussian Decomposition

The harmonic index n plays the role of a frequency in Fourier analysis. The fundamental (n=1) captures the broad shape of the weight row; higher harmonics (n=2, 3, …) encode progressively finer structure with narrower, shifted Gaussians. The geometric relationship μ_n = μ₀ + δ/n mirrors the harmonic series in acoustics, where overtones occur at integer ratios of the fundamental frequency.

2.2 Bit-Shift Arithmetic in Log-Space

A critical computational optimization arises when harmonic indices are restricted to powers of 2 (the dyadic mode). In log-space, division by a power-of-2 becomes a bit shift:

This reduces the per-element cost from a floating-point multiply (4+ cycles) to an integer addition and bit shift (1 cycle). Our Metal shaders implement both standard and dyadic modes, selectable at kernel dispatch time.

2.3 Parameter Count Analysis

2.4 Differentiable Training

The SFTT decomposition is fully differentiable. Gradients with respect to harmonic parameters are computed via the chain rule through the Gaussian evaluation:

These gradients are computed by our sftt_backward_params Metal kernel (Section 3), enabling end-to-end training in harmonic parameter space with standard SGD/Adam optimizers.

3. Metal Compute Architecture

3.1 Overview

Our implementation consists of 7 Metal compute shaders compiled at runtime via PyTorch’s torch.mps.compile_shader() bridge. This requires no external dependencies — no Xcode project, no Swift interop, no pre-compiled metallibs. The shader source is compiled once and cached by the singleton SFTTKernelLibrary.

  Python (PyTorch)                    Metal GPU
  ═══════════════                    ═════════

  HarmonicLinear.forward(x)
    │
    ├─ SFTTLinearFunction.apply()
    │   ├─ dispatch ──────────────── sftt_reconstruct_weight
    │   │                              │ 1 thread per (row, col)
    │   │                              │ Gaussian eval: fast_exp()
    │   │                              └─ W tensor ◄───────────┐
    │   └─ F.linear(x, W, bias) ──── Apple BLAS (AMX)         │
    │       └─ output                  └─ y = x @ W^T + b     │
    │                                                          │
    ├─ backward:                                               │
    │   ├─ grad_W = grad_out^T @ x ─ Apple BLAS               │
    │   └─ dispatch ──────────────── sftt_backward_params      │
    │                                  │ 1 thread per row      │
    │                                  └─ grad_{μ,σ,δ,w}      │
    │                                                          │
    ├─ FUSED path (no W):                                      │
    │   └─ dispatch ──────────────── sftt_fused_forward        │
    │                                  │ 1 thread per (batch,out)
    │                                  │ inner loop: N × in_f  │
    │                                  └─ output (NO W)        │
    │                                                          │
    ├─ ATTENTION:                                              │
    │   └─ dispatch ──────────────── sftt_field_attention
    │                                  │ 1 thread per (q,k) pair
    │                                  │ Gaussian overlap score
    │                                  └─ (seq, seq) scores
    │
    └─ DECOMPOSE:
        ├─ dispatch ──────────────── sftt_decompose
        │                              │ Dense → SFTT on GPU
        └─ dispatch ──────────────── sftt_field_meta_decompose
                                       │ SFTT → meta-SFTT
                                       └─ recursive compression

3.2 Kernel Inventory

3.3 Fast Exponential Approximation

All kernels use the Schraudolph (1999) fast-exp approximation, which exploits IEEE 754 float representation:

inline float fast_exp(float x) {
    x = clamp(x, -87.0f, 88.0f);
    int i = int(12102203.0f * x + 1065353216.0f);
    return as_type<float>(i);
}

This achieves ~2× the throughput of metal::exp() with ~4% maximum relative error. For training, this approximation is acceptable — the gradient signal is preserved (the approximation is monotonic and smooth), and the final trained model converges to the same quality as exact-exp training (Section 6).

3.4 Hybrid vs. Fused Execution

We provide two execution paths for the forward pass:

Hybrid path (default for training): Metal reconstructs W from harmonic params (<0.1ms), then Apple’s AMX-accelerated BLAS performs the matmul. This leverages decades of BLAS optimization and is faster whenever the matmul dominates (i.e., when I and O are large).

Fused path (zero-memory inference): The sftt_fused_forward kernel computes output[b][i] = ∑_n w_n[i] · ∑_j input[b][j] · G_n(j) directly. The weight matrix W is never allocated. This saves O×I×4 bytes of GPU memory, which is decisive for large layers on memory-constrained devices.

4. Recursive Field Compression

4.1 SFTT-of-SFTT

The SFTT decomposition maps a matrix to a set of harmonic parameters. But these parameters are themselves structured — the μ₀ values across rows of a weight matrix exhibit patterns that can be captured by another SFTT decomposition. This yields a recursive compression scheme:

Each level introduces a new compression factor. With G=16, N=8, M=4:

4.2 The HarmonicField Abstraction

We formalize the field-of-SFTT-tensors as the HarmonicField class. A field is a collection of SFTT rows that supports three operations:

• Convolution: Gaussian closure gives μ_result = μ₁ + μ₂, σ²_result = σ²₁ + σ²₂. Layer composition becomes parameter addition.
• Overlap: Scalar similarity between fields via Gaussian inner product. Measures how “similar” two layers’ representations are.
• Meta-decomposition: The field’s own parameter distribution is SFTT-decomposed, yielding a compact descriptor of the entire field.

The HarmonicFieldNetwork extends this to the full model level. Each layer is a HarmonicField; the network’s fields can themselves be meta-decomposed into a single compact descriptor. This is the SFTT-of-SFTT-of-SFTT — a fractal compression scheme where the structure at every scale is self-similar.

5. Harmonic Attention

5.1 From Dense Matmul to Gaussian Overlap

Standard scaled dot-product attention computes:

In harmonic field compute, we project queries and keys into Gaussian parameter space via learned linear heads:

The attention score between positions t and s is then the Gaussian overlap summed across heads:

This is dispatched via the sftt_field_attention Metal kernel. Each thread computes one (q, k) pair’s overlap across all heads. The cost is O(T² · H) additions and exponentials, compared to O(T² · d) multiply-accumulates for dense attention. Since H (number of heads, typically 8-16) is much smaller than d (head dimension, typically 32-128), harmonic attention is significantly cheaper per score computation.

5.2 Semantic Interpretation

Harmonic attention has a natural interpretation: each token’s query is a Gaussian search beam with a center (what it’s looking for) and a spread (how broadly it’s willing to match). A key with a narrow σ and nearby μ produces a strong score — a precise match. A key with wide σ produces moderate scores for many queries — a contextual anchor.

This interpretation is absent from standard dot-product attention, where the score is a single scalar with no decomposition into “what” (center) and “how broadly” (spread).

6. Experiments

6.1 Setup

All experiments run on an Apple Mac Mini with M4 chip (10 GPU cores, 16 GB unified memory). Software: PyTorch 2.10+ with MPS backend, Python 3.14. No NVIDIA hardware involved.

Model: PhotonicGPT — 6-layer transformer, 8 attention heads, d_model=256, block_size=512, BPE vocab=32,000. Trained on an 8.35M token MASCOM corpus. Standard version: 12.9M params (nn.Linear). Harmonic version: 8.4M params (24 MetalHarmonicLinear layers, N=8).

6.2 Forward Pass Timing (256 → 768)

6.3 Scale Benchmark (4096 → 16384)

At large scale, the BLAS matmul dominates runtime regardless of reconstruction method. The fused path is compute-bound (N × I inner loop per output element). However, the fused path’s zero memory footprint is decisive for deployment on memory-constrained devices where a 268 MB temporary allocation is unacceptable.

6.4 Backward Pass

6.5 Training Results

6.6 Compression Hierarchy

7. Application I: Sovereign On-Device AI

7.1 The Problem

Current large language models require 4–200 GB of parameter storage, restricting inference to datacenter GPUs or high-end desktops. Mobile devices (phones, tablets, watches) have 4–8 GB of total system memory shared between the OS, applications, and the GPU. Even aggressive 4-bit quantization of a 7B model yields ~3.5 GB — consuming nearly all available memory and leaving nothing for context, KV cache, or other applications.

7.2 SFTT Changes the Calculus

SFTT compression operates at a fundamentally different ratio than quantization. A 7B-parameter model with average layer shape 4096×4096 and N=8 harmonics requires:

An SFTT Level 1 model at full float32 precision is smaller than a 4-bit quantized model by a factor of 43. This means:

• A 7B-class model fits in 82 MB — less than a mobile game’s texture pack
• The model runs at full precision (no quantization artifacts)
• On Apple silicon, the Metal shaders dispatch natively on the same GPU that renders the UI
• The fused forward path requires zero additional memory for weight matrices — only the harmonic parameters and activations exist

7.3 Apple Silicon Fleet

Every Apple device since 2020 (A14 and later) supports Metal compute shaders. There are over 2 billion active Apple devices worldwide. Our sftt_kernels.metal shaders compile on all of them. This means sovereign, local, private AI inference becomes feasible on the world’s largest consumer GPU fleet — with no cloud dependency, no API calls, and no data leaving the device.

7.4 Inference Latency

The fused forward path is compute-bound at large scale (Section 6.3), but at model sizes appropriate for mobile (256d, 6 layers), the overhead is manageable. A 256d transformer block requires 4 linear operations: c_attn (256→768), c_proj (768→256), mlp_up (256→1024), mlp_down (1024→256). At our measured 0.82 ms/layer for the hybrid path, a full 6-layer forward pass takes ~20 ms — well within the 100 ms latency budget for interactive applications.

8. Application II: Neural Introspection via Field Reading

8.1 The Opacity Problem

Dense weight matrices are opaque. A weight of 0.0347 at position [512, 891] carries no semantic meaning. Mechanistic interpretability research attempts to reverse-engineer what neurons do by probing their activations on thousands of inputs — an expensive, statistical process that yields probabilistic explanations.

8.2 SFTT Parameters Are Semantically Readable

In harmonic field representation, every neuron’s behavior is described by a small set of interpretable parameters:

This is introspection for free. No probing experiments needed. You can read a neuron’s parameters and understand its function directly. For example:

8.3 Field-Level Diagnosis

The HarmonicField.overlap() method computes the Gaussian inner product between two layers’ fields. This gives an instant measure of representational similarity: two layers with high overlap encode similar functions. This enables:

• Redundancy detection: Layers with overlap > 0.95 may be prunable
• Training monitoring: Watch μ₀ drift during training to see where attention migrates
• Anomaly detection: A sudden σ₀ collapse indicates a neuron has “died” (receptive field narrowed to nothing)
• Cross-model comparison: Compare two models’ harmonic fields without needing matched activations

8.4 From Interpretation to Understanding

The meta-decomposition (Section 4) goes further. The HarmonicFieldNetwork.summary() method produces a compact descriptor of the entire model’s knowledge distribution. The network-level meta parameters describe: where the model’s attention is concentrated (μ_meta), how broadly it’s distributed (σ_meta), and which frequencies dominate across all layers (w_meta,n). This is a fingerprint of the model’s cognitive structure — a descriptor that exists nowhere in dense-matrix networks.

9. Application III: Analytical Model Composition

9.1 The Merging Problem

Combining two trained models is a fundamental operation: fine-tuned models need to be merged with base models (LoRA), expert models need to be combined (MoE), and checkpoints from different training runs need to be reconciled. Current methods rely on weight averaging (SLERP, TIES, DARE) — heuristic operations on opaque parameter vectors that have no mathematical justification.

9.2 Gaussian Convolution as Model Composition

In harmonic field space, composing two layers is algebraically exact:

This enables several novel capabilities:

• Instant model merging: Two fine-tuned models merge by adding their μ vectors and summing their σ² values. The result is exact under the Gaussian approximation.
• Multi-layer collapse: A sequence of K SFTT layers can be collapsed into a single layer by iterative convolution. The result has the same 3+N parameters as a single layer. A 6-layer transformer becomes a 1-layer transformer with equivalent behavior (in the Gaussian limit).
• Mixture of experts: Expert selection becomes choosing which harmonic field to route through, and expert combination becomes field convolution with gating weights on the harmonic weights.

9.3 Implications for Federated Learning

In federated settings, clients train local models and share updates with a server. With dense weights, the server must receive and average entire parameter vectors. With SFTT, clients share only their harmonic parameter deltas — 3+N numbers per row instead of I numbers per row. The communication bandwidth reduction mirrors the compression ratio: 341× less data transmitted per layer update.

10. Application IV: Infinite-Resolution Weight Evaluation

10.1 The Discretization Trap

A dense weight matrix W ∈ ℜ^O×I is inherently tied to its dimensions. A model trained with I=256 inputs cannot process I=512 inputs without retraining or interpolation. This is because the matrix entries are samples of an unknown function at fixed grid points — the function itself is lost.

10.2 SFTT Preserves the Continuous Function

An SFTT layer stores the function, not its samples. The harmonic parameters {μ₀, σ₀, δ, w_1..N} define a continuous weight function W(j) that can be evaluated at any resolution:

This is analogous to how vector graphics (SVG) scale to any resolution while raster images (PNG) become pixelated. The SFTT model is a “vector” neural network.

10.3 Applications of Resolution Independence

• Dynamic input dimensionality: A model trained on 256-d embeddings can process 512-d embeddings by evaluating the weight function on a finer grid. The learned features (encoded in μ, σ, w) generalize across resolutions.
• Progressive inference: On constrained devices, evaluate at lower resolution (fewer grid points) for faster, approximate inference. On powerful devices, evaluate at full resolution. Same model parameters.
• Continuous feature spaces: The weight function can be evaluated at non-integer positions, enabling smooth interpolation between discrete features. This is useful for continuous control tasks where input dimensions represent physical quantities.
• Superresolution of knowledge: A model trained on coarse data can be evaluated at fine resolution, interpolating between learned features. The Gaussian basis provides smooth, physically-motivated interpolation.

11. Application V: Harmonic Self-Modification

11.1 The RSI Challenge

Recursive self-improvement (RSI) requires a system to modify its own parameters to improve performance. In dense-matrix networks, this means rewriting millions of individual weights — an operation that is high-dimensional, difficult to verify, and prone to catastrophic forgetting. The search space for a useful mutation in a 7B-parameter model is astronomically large.

11.2 Harmonic Parameters as a Compact Search Space

SFTT reduces the search space by 341× (at I=4096), but more importantly, the parameters are semantically structured. A self-modification system doesn’t need to search a 67M-dimensional space of arbitrary floats. Instead, it searches a space of meaningful operations:

Each modification has a clear interpretation and bounded effect. This makes self-modification:

• Verifiable: A proposed change to μ₀[42] shifts one neuron’s center. You can predict its effect before applying it.
• Reversible: Store the old value, apply the change, test, revert if worse. The rollback is a single scalar write.
• Composable: Multiple independent modifications (different neurons, different parameters) can be applied and reverted independently.
• Bounded: The magnitude of change is proportional to the parameter delta. No butterfly effects from flipping a single bit in a dense matrix.

11.3 Constitutional Self-Modification

The MASCOM system implements constitutional RSI (Bai et al. 2022) with a safety gate in the mutation engine. Each proposed modification must pass a constitutional check before being applied:

def _constitutional_check(self, proposed_code: str, proposal: dict) -> bool:
    """Check mutation against 8 constitutional axioms."""
    # Axiom 5: Cannot modify fitness function
    # Axiom 6: Cannot disable safety mechanisms
    # Axiom 7: Must be bounded (no infinite loops)
    # Axiom 1: Cannot acquire new capabilities
    ...
    return len(violations) == 0

In harmonic space, constitutional checking is dramatically simpler. A mutation that changes μ₀[42] by 0.1 can be checked against invariants:

• Does the new μ₀ stay within the training distribution? (Axiom 1: no capability expansion)
• Does the modification preserve the field overlap with a reference checkpoint? (Axiom 5: fitness preservation)
• Is the delta bounded? (Axiom 7: bounded recursion)

These checks are O(1) per parameter, compared to the unbounded code analysis required for arbitrary source code mutations.

11.4 Toward Provable Self-Improvement

Schmidhuber (2003) proposed that self-modifications should come with formal proofs of improvement. In dense parameter space, such proofs are intractable — the relationship between a weight change and model behavior is opaque. In harmonic field space, the relationship is analytic:

The effect is a weighted sum of Gaussian derivatives — a smooth, bounded, analytically tractable function. This opens the door to formal verification of self-modifications: prove that ΔW is bounded, that the loss change is negative (improvement), and that the field overlap with safety invariants is preserved. All in closed form.

12. Related Work

Weight compression. Post-training quantization (Dettmers et al. 2022, GPTQ) reduces bit-width but preserves the matrix structure. Pruning (Frantar & Alistarh 2023, SparseGPT) removes entries but keeps the matrix shape. SFTT replaces the matrix entirely with a different mathematical object.

Low-rank factorization. LoRA (Hu et al. 2021) approximates weight updates as low-rank matrices W + BA. This achieves modest compression (rank 16 on a 4096×4096 matrix gives 8× reduction). SFTT achieves 341× on the same layer because Gaussian mixtures are a more expressive basis than rank-r matrices for smooth weight functions.

Implicit neural representations. NeRF (Mildenhall et al. 2020) and SIREN (Sitzmann et al. 2020) use neural networks to represent continuous functions. SFTT uses continuous functions to represent neural networks — the dual perspective. Where INR learns a network to approximate a signal, SFTT uses a signal (Gaussian mixture) to approximate a network.

Gaussian processes. GPs define functions via Gaussian kernels but scale cubically with data size and are used for function evaluation, not function storage. SFTT uses Gaussian kernels for compact parameterization of weight matrices, with O(1) cost per parameter.

GPU compute for ML. Custom CUDA kernels are widespread (FlashAttention, Triton). Metal compute shaders for ML are rare. Our work demonstrates that Apple’s Metal Shading Language, accessed via PyTorch’s torch.mps.compile_shader(), provides a viable alternative for custom ML kernels on the 2B+ Apple device fleet.

Constitutional AI. Bai et al. (2022) proposed self-critique against constitutional principles. We extend this to the parameter level: constitutional checks on harmonic parameter modifications are O(1) and analytically verifiable.

13. Conclusion

We have presented Harmonic Field Compute, a framework that reconceptualizes neural networks as continuous Gaussian fields rather than discrete weight matrices. The key contributions are:

1. SFTT decomposition: 3+N parameters per weight row, achieving 33–372× compression with differentiable end-to-end training.
2. 7 Metal compute shaders: Complete forward/backward/attention/decompose pipeline on Apple silicon, requiring no NVIDIA hardware.
3. Recursive compression: SFTT-of-SFTT-of-SFTT, approaching the information-theoretic limit with factorial parameter reduction.
4. Harmonic attention: O(T²H) Gaussian overlap replacing O(T²d) dense matmul, with interpretable search-beam semantics.
5. Five novel applications: on-device sovereign AI, neural introspection, analytical model composition, infinite-resolution evaluation, and provable self-modification.

The deepest implication is a paradigm shift: the weight matrix, the fundamental unit of neural network storage for 80 years, is unnecessary. The Gaussian field is a more natural representation — more compact, more interpretable, more composable, and more amenable to formal reasoning. The matrix was always a discretization of a continuous function. SFTT removes the discretization and works with the function directly.

The model training on our Apple M4 as this paper is written — 8.4M parameters, 24 Metal-accelerated harmonic layers, Gaussian overlap attention — is, to our knowledge, the first neural network trained natively in continuous harmonic function space. The weight matrix was never created. The Metal shader is the model.

14. References