MobleyDiffusion: Recursive Permutative Diffusion Over Discrete Token Spaces With Self-Inferring Target Distributions

1. Introduction

The dominant paradigm in generative modeling assumes a fixed target distribution p(x) learned from data through gradient descent over millions of parameters. Diffusion models (Ho et al. 2020, Song et al. 2021) add Gaussian noise in a forward process and learn to reverse it, operating in continuous space over real-valued vectors. This paper takes a fundamentally different approach.

But we go further. Rather than using a pretrained language model as a black box, we build the generative process from first principles: discrete masked diffusion over palette indices, with the energy landscape (target distribution) inferred recursively from the system's own outputs. The model discovers what "good" means while generating, rather than learning it from a fixed dataset.

This addresses the open problem identified in the theoretical seed: "No mainstream architecture [performs] target inference during sampling" (Section 5 of the preliminary analysis). MobleyDiffusion does exactly this.

1.1 Contributions

1. Discrete Masked Diffusion — Forward process masks positions with a MASK token (index 17); reverse process predicts original palette indices. No Gaussian noise, no continuous space, no reparameterization trick.
2. Sieve-Based Complexity Collapse — Five structural sieves (silhouette, anatomy, symmetry, palette coherence, connectivity) eliminate entire equivalence classes, reducing n! to O(n^k).
3. Recursive Manifold Updates — Generated samples update the energy landscape E(x) = -log p(x). The manifold reshapes itself based on output quality: E_t+1(x) = H[E_t(x), {x_s}].
4. Inductive Diffusion — Reversed-gradient exploration pushes samples INTO high-energy anti-solution space. Positions that resist disruption (Hawking radiation at the event horizon of structure) become hard constraints for recovery.
5. Holographic Generation — Multiple diffusion trajectories run in parallel, averaged via quality-weighted voting. Coherent structure reinforces; noise cancels. The Feynman path integral applied to discrete generation.
6. Nested Attractor Hierarchy — Three-level basin structure (humanoid → archetype → individual) with cross-character transfer learning at 10% anatomical region weight.
7. Temporal 4D Manifold — Animation frames modeled as slices of a 4D energy manifold E(x, y, color, t), producing temporally coherent animation sequences.
8. Zero-Dependency Implementation — 3,027 lines of pure Python. No PyTorch, no TensorFlow, no external APIs. Fully sovereign.

2. Theoretical Foundation

2.1 The Combinatorial Explosion Problem

A 16×24 sprite with 16 colors has 16³⁸⁴ ≈ 10⁴⁶² possible configurations. This is vastly larger than the number of atoms in the observable universe (~10⁸⁰). Brute enumeration is impossible. Even sampling uniformly would never produce structure.

The key observation: permutations grow as n!, combinations as n!/(k!(n-k)!). But structured visual output is neither — it occupies a tiny manifold embedded in the full combinatorial space. The challenge is finding that manifold without enumerating the space.

2.2 Diffusion as Probability Gravity

Training data curves probability space the way mass curves spacetime. Generated samples "fall" into attractor basins — faces, sprites, text — the way matter falls into gravity wells.

2.3 The Recursive Feedback Loop

Mass tells spacetime how to curve.
Spacetime tells mass how to move.

Becomes:

Samples tell the manifold how to curve.
The manifold tells samples where to go.

MobleyDiffusion implements this literally. Each generation cycle:

The energy landscape E(x) is not fixed. It evolves. The system learns what "good sprite" means through its own outputs.

2.4 Wick Rotation and the Discrete Analogue

The Schrödinger equation and the diffusion equation are related by Wick rotation (t → iτ). MobleyDiffusion operates in discrete imaginary time — each reverse step is a discrete tick of the Wick-rotated process. The MASK token plays the role of the vacuum state. Unmasking is particle creation from the probability vacuum.

3. Architecture

3.1 State Space

• Grid: 16 wide × 24 tall = 384 positions
• Palette: 16 color indices (0 = transparent, 1-15 = character colors)
• MASK token: Index 17 (beyond palette, signals unknown)
• State: A sprite is a vector s ∈ {0, 1, ..., 15, 17}³⁸⁴

3.2 Energy Manifold

The energy manifold stores E(pos, color) for each position-color pair:

Lower energy = higher probability. The Boltzmann distribution gives:

Curvature at each position measures energy variance: κ(pos) = Var_color[E(pos, color)]. High curvature means the manifold has strong opinions. Low curvature means uncertainty.

Voids are positions where the manifold has been disrupted. Voids emit disturbance waves that propagate outward, influencing nearby predictions through interference.

3.3 Forward Process

def forward(self, grid, noise_level):
    masked = list(grid)
    for pos in range(384):
        if random() < noise_level:
            masked[pos] = MASK_TOKEN
    return masked

Discrete corruption — no Gaussian noise, no variance schedule. A position is either known or unknown.

3.4 Reverse Process

Each reverse step:

1. Predict all masked positions using a 4-layer prediction stack:
   • Layer 1: Corpus frequency prior
   • Layer 2: Manifold energy distribution (Boltzmann sampling)
   • Layer 3: Neighbor context
   • Layer 3.5: Archetype hierarchy prior
   • Layer 4: Disturbance wave influence (interference patterns)
2. Apply sieves — hard structural constraints that zero out impossible configurations
3. Compute geodesic order — unmask highest curvature first (steepest probability gradient)
4. Apply hyperdiffusion rates — curvature-accelerated unmasking
5. Langevin noise injection — small probability of Boltzmann sampling to prevent mode collapse

3.5 Sieve System

Recursive Sieve Learning: Sieves learn from output quality. Positions that consistently correlate with high quality become frequency-locked. Color transitions in high-quality outputs become transition priors. The sieve system self-improves across generations.

3.6 Geodesic Flow

High-curvature positions are unmasked first because the manifold has the strongest signal there. Low-curvature positions are deferred to later steps when surrounding context provides more information. This is the discrete analogue of following geodesics on a Riemannian manifold.

4. Novel Mechanisms

4.1 Inductive Diffusion (Reversed Gradient)

Standard diffusion moves from noise to structure (deductive). Inductive diffusion does the opposite — pushes structured output INTO high-energy anti-solution space:

Note the positive gradient — this is uphill, toward chaos. The process deliberately destroys structure. But not all structure is equally fragile.

This is the paper's key insight: you learn more about structure by trying to destroy it than by trying to build it.

4.2 Shell Boundary Oscillation

The sprite has two boundaries: interior (pixel-to-pixel) and exterior (pixel-to-transparent). The shell oscillator cycles between them — exterior phase smooths the silhouette, interior phase enforces color coherence. One cycle produces cleaner edges and more coherent interiors than either phase alone.

4.3 Simultaneous Minima Punching

Local minima in the energy landscape trap the generation process. Rather than annealing, MobleyDiffusion punches through multiple minima simultaneously: find all local minima, perturb each, re-predict with perturbations active. The interference pattern between perturbed predictions reveals global structure. This is analogous to quantum tunneling.

4.4 Disturbance Wave Propagation

When the manifold is disrupted, the disruption propagates outward as a wave. Waves interact with predictions through interference:

• Constructive interference (positive phase): boost the most likely color
• Destructive interference (negative phase): spread probability more evenly

Multiple waves create interference patterns across the grid. Coherent structure emerges from positions where waves reinforce; exploration happens where waves cancel.

4.5 Holographic Generation (Feynman Path Integral)

Multiple diffusion trajectories run in parallel with different noise levels and strategies (half standard, half inductive). Results combined via quality-weighted voting:

for each position:
    votes[color] += quality_weight[trajectory]
    result[pos] = argmax(votes)

All paths contribute, weighted by their "action" (quality score). Coherent structure reinforces across trajectories. Noise, being random, cancels.

4.6 Recursive Manifold Updates

Good outputs lower the energy of their configurations. Bad outputs raise it. The manifold develops topography:

• Attractor basins form around high-quality configurations
• Ridges form between distinct attractor types
• Voids appear where the system has explored and found nothing good

The manifold converges when quality scores plateau — the geometry has stabilized. The target distribution is not given — it is inferred recursively from the system's own outputs.

5. Extension Architecture

5.1 Nested Attractor Hierarchy

5.2 Cross-Character Manifold Transfer

Generating character A transfers learning to same-archetype characters. Additionally, anatomical region transfer applies at 10% weight across ALL archetypes — a good torso learned from a warrior improves torso generation for mages and rogues, because humanoid anatomy is shared.

5.3 Temporal Manifold 4D

Frame-to-frame color transitions are learned. The 4D manifold is sliced at each frame index to produce individual frames, but the temporal dimension ensures smooth transitions.

5.4 Multi-Scale Progressive Resolution

Each scale constrains the next via upsampling. Coarse structure propagates as hard constraints at 70% of positions.

5.5 25 Animation Type Generation

Full animation type support: walking (9 frames), attacking (6), casting (8), jumping (4), dying (4), swimming (6), sneaking (6), climbing (4), blocking (3), idle_combat (4), victory (6), defeat (4), running (8), rolling (4), crouching (3), flying (6), mounted (6), carrying (4), pushing (3), pulling (3), falling (3), landing (3), sitting (4), sleeping (3), emoting (4).

6. Experimental Results

6.1 Configuration

• Corpus: 19 characters, 380 seed frames (20 per character)
• Grid: 16×24 = 384 positions, 16 colors + MASK token
• Hardware: Apple M-series, single core, pure Python
• No training: Zero gradient updates, zero parameters learned

6.2 Results by Generation Mode

6.3 Key Findings

1. Holographic generation is the best single mode — 0.832 overall. Color coherence jumps from 0.31 to 0.36 (16% relative improvement) because noise cancels across trajectories.
2. Silhouette preservation is near-perfect (0.97-0.98) — the sieve system enforces body shape as a hard constraint.
3. Structure score of 1.00 means a single connected component — no floating pixels. The connectivity sieve eliminates fragmentation.
4. Multi-scale needs development — 0.620 quality suggests coarse-to-fine propagation loses information in upsampling.

6.4 Manifold Convergence

7. Comparison to Existing Work

8. Mathematical Framework

8.1 Energy Landscape

8.2 Recursive Update Rule

Good samples (high q) lower the energy of their configurations.

8.3 Geodesic Unmasking

Geodesic order: descending curvature. Unmask where most confident first.

8.4 Sieve Collapse

8.5 Inductive Energy

Positions where ∂E/∂x is largest resist disruption — these are the Hawking radiation constraints at local energy minima.

8.6 Holographic Averaging

Quality-weighted majority voting — the discrete analogue of the Feynman path integral.

9. Discussion

9.1 Why This Works Without Training

The sieve system provides the structural prior that neural networks learn from millions of examples. A neural network learns "sprites have connected body shapes" from thousands of sprites. The silhouette sieve encodes this directly. The manifold provides the distributional prior — but instead of fixing it after training, MobleyDiffusion discovers it on the fly.

9.2 The Einstein Analogy Realized

The theoretical framework predicted that recursive diffusion would exhibit Einstein-like feedback. This is exactly what the manifold update loop does. A high-quality mage sprite lowers the energy of mage-archetype configurations, which makes future mage sprites more likely to be high-quality, which further lowers the energy. The system finds a fixed point — the converged manifold — where geometry is self-consistent.

9.3 Implications for Sovereign AI

MobleyDiffusion demonstrates that structured visual generation is possible without neural network training, GPU compute, external APIs, large datasets, or continuous mathematics. The entire system runs on a single CPU core in pure Python. This matters for AI sovereignty — the ability to generate art without depending on any external provider.

9.4 Limitations

1. Quality ceiling: 0.832 is good but not photorealistic. The discrete 16-color space inherently limits visual fidelity.
2. Multi-scale weakness: 0.620 quality on multi-scale generation — coarse-to-fine propagation needs work.
3. Speed: Pure Python is slow. A compiled implementation would be significantly faster.
4. No perceptual evaluation: Quality scores are geometric, not perceptual.
5. Seed dependency: Initial quality depends on the seed corpus.

10. Future Work

1. LLM as prediction oracle: Replace the statistical predictor with an LLM. The PredictionOracle interface is already pluggable.
2. Perceptual quality metric: Train a classifier on human quality judgments for manifold update weighting.
3. Higher resolution: Extend to 32×48 or 64×96 with improved multi-scale propagation.
4. Cross-game transfer: Pre-trained manifolds transferred across art styles via shared Level 0 attractors.
5. Real-time generation: Compiled implementation with SIMD and parallel trajectories.

11. Conclusion

MobleyDiffusion is the first implementation of recursive permutative diffusion with self-inferring target distributions. The system generates structured 16-color pixel art sprites at 0.832 quality using discrete masked diffusion, five structural sieves, geodesic unmasking, hyperdiffusion, inductive exploration, shell boundary oscillation, simultaneous minima punching, disturbance wave propagation, holographic path integral averaging, nested attractor hierarchies, cross-character manifold transfer, and temporal 4D animation modeling — all in 3,027 lines of pure Python with zero external dependencies.

References

1. Ho, J., Jain, A., & Abbeel, P. (2020). Denoising Diffusion Probabilistic Models. NeurIPS.
2. Song, Y., Sohl-Dickstein, J., Kingma, D.P., et al. (2021). Score-Based Generative Modeling through Stochastic Differential Equations. ICLR.
3. Austin, J., Johnson, D.D., Ho, J., Tarlow, D., & van den Berg, R. (2021). Structured Denoising Diffusion Models in Discrete State-Spaces (D3PM). NeurIPS.
4. Sahoo, S., Arriola, M., Schiff, Y., et al. (2024). Simple and Effective Masked Diffusion Language Models (MDLM).
5. Ren, J., et al. (2025). Diffusion Model Is Effectively Its Own Teacher. CVPR.
6. Sun, H., et al. (2024). SAIL: Self-Amplified Iterative Learning.
7. Feynman, R.P. (1948). Space-Time Approach to Non-Relativistic Quantum Mechanics. Reviews of Modern Physics.
8. Lovheim, H. (2012). A new three-dimensional model for emotions and monoamine neurotransmitters. Medical Hypotheses.
9. Baars, B.J. (1988). A Cognitive Theory of Consciousness. Cambridge University Press.

Appendix A: Full Test Output

Appendix B: CLI Interface

python3 mobley_diffusion.py --generate claudine       # Single character atlas
python3 mobley_diffusion.py --generate-all             # All 19 beings
python3 mobley_diffusion.py --holographic claudine     # Holographic (8 paths)
python3 mobley_diffusion.py --inductive claudine       # Inductive cycle
python3 mobley_diffusion.py --multiscale claudine      # Progressive resolution
python3 mobley_diffusion.py --animate claudine         # Walking animation
python3 mobley_diffusion.py --animate claudine --animate-type attacking
python3 mobley_diffusion.py --evolve 10                # Manifold evolution
python3 mobley_diffusion.py --visualize-manifold       # Energy heatmap
python3 mobley_diffusion.py --metrics                  # Convergence diagnostics
python3 mobley_diffusion.py --preview                  # HTML preview
python3 mobley_diffusion.py --atlas                    # Haven-compatible export
python3 mobley_diffusion.py --world-seed --biome desert --elevation 3
python3 mobley_diffusion.py --test                     # Full 20-phase validation