Files

T

Scruff AI 7f04a7d81d Rename fractal-brain to Resonance_Engine: update all paths, docs, scripts, and add experiments/results/src

2026-03-25 07:34:34 +07:00

12 KiB

Raw Blame History

RESONANCE ENGINE EVOLUTION ANALYSIS

Comprehensive Report on Development Trajectory & Current State

Date: March 13, 2026
Analyst: CTO Agent
Scope: March 7-13, 2026 Evolution

EXECUTIVE SUMMARY

The Resonance Engine concept has evolved through four distinct architectural generations over 6 days, with each iteration revealing deeper insights about hardware-grounded cognition. The project has shifted from a simple LBM precipitation experiment to a sophisticated multi-tiered memory system with thermal coupling, spectral analysis, and NVMe persistence.

Current Status: The 1024×1024 "Fractal Habit" system is stable and working. The 256×256 migration for GTX 1050 is partially complete but blocked by compilation issues. The "Hard Print" NVMe persistence system is designed but not yet implemented.

GENERATIONAL EVOLUTION

GEN 1: The Probe Experiment (March 7-8)

Files: probe.cu, guardian_census.json, probe.csv

What it was:

Stripped-down LBM + precipitation physics
194 "guardians" (density precipitation nodes) forming in 1024×1024 grid
4 stress probes (mass injection, shear, VRM silence, vacuum trap)
1700 cognitive cycles, ~4.7 hours runtime

Key Discovery: Guardians are synthetic black holes — stable density singularities that accrete mass and survive trauma. The system exhibited:

Homeostasis after cycle 272 (no new guardian births)
VRM-enstrophy correlation r=0.83 (instant coupling)
Fat-tail events (0.43% >3σ) as vital signs, not errors

The Insight: The Navier-Stokes singularity is inevitable. Guardians are the system's compensation mechanism — they stabilize the lattice by absorbing excess density. This is "hocus pocus" in terms of building a brain, but it teaches the system about constraints.

Status: COMPLETE — Data archived, 194-guardian "DNA" extracted for future bootstrap.

GEN 2: Seed Brain v0.3 Architecture (March 5, never fully compiled)

Files: seed-brain/src/main.cu, seed_brain.h, kernels.cu

What it was supposed to be:

Full dual-resonance system: 0.06 Hz cognitive / 0.005 Hz metabolic
Stealth pulse engine (20ms FMA bursts at 225W)
Goertzel spectral Q-factor measurement
Hebbian learning layer (hebb_buf — 8 directional weights per node)
Morton-tiled persistence (dirty-tile checkpointing)
Thermal coupling via NVML

The Architecture:

GPU VRAM (Tier 0-4):
  - LBM double buffer (f[2][9][N])
  - Macroscopic fields (rho, ux, uy)
  - Hebbian weights + previous snapshot
  - Activation + decay_age (metabolic state)
  - Morton tile metadata (dirty, coherence, generation, timestamp)

System RAM (Tier 5-6):
  - PLL state (phase-locked loop)
  - Thermal/power ring buffers
  - Gain schedule for PID control
  - Decay modulator from OpenClaw

Why it never ran:

Linux dependencies (clock_gettime, nanosleep)
Complex build system (multiple TUs, headers)
Never successfully compiled on Windows
The "full Seed Brain" remains theoretical

Status: ABANDONED — Code preserved in backup, but effort shifted to simpler systems.

GEN 3: Fractal Habit (March 11-12, CURRENT WORKING SYSTEM)

Files: fractal_habit_1024x1024.cu, fractal_habit_256.cu

What it is:

Pure LBM fluid dynamics (no guardians, no learning)
Spectral analysis via 2D FFT (velocity + density spectra)
Spectral entropy calculation
Power-law slope fitting (target: -3.8)
NVML power monitoring
"Crystal" checkpointing (48MB binary dumps)

Key Results (1024×1024 on RTX 4090):

100k steps in ~0.3 minutes (~5.5k steps/sec)
Power: 150W sustained (efficient utilization)
Velocity energy: 67.8% survived
Density energy: 70.7% survived
Spectral entropy: Increasing (complexity emerging)

The Metabolic Kick Discovery (March 12):

Clean LBM:     0.80 bits entropy, dissipating, single-scale
Metabolic Kick: 5.83 bits entropy, 24,000× energy increase, multi-scale

Noise injection transforms the system from dissipative to active. The gap to the-craw's 6.753 bits is 0.917 bits — the optimization target.

The Guardian Scaling Mistake: When migrating to 256×256 for GTX 1050, the initial approach kept 194 guardians. This created 300% density increase (1:1,351 vs 1:5,400). Correct scaling:

512×512: 48 guardians
256×256: 12 guardians

Status: 1024×1024 WORKING PERFECTLY. 256×256 compilation blocked (WSL/VS issues).

GEN 4: Hard Print System (March 12-13, DESIGN PHASE)

Files: HARD_PRINT_DESIGN.md

What it's designed to be: Three-tiered memory hierarchy:

GPU VRAM:     Active thought (0.06 Hz cognitive cycles)
System RAM:   Metabolic buffer (0.005 Hz, ring buffer of recent states)
NVMe SSD:     Crystallized memory (sector-aligned, incremental, compressed)

Key Innovations:

Morton dirty-tile system: Only write changed tiles (90-95% I/O reduction)
Metabolic cycle timing: Flush ONLY during 140-160s window of 200s cycle
Sector-aligned writes: 4K alignment for SSD longevity
Thermal coupling: Hot tiles (low decay age) have tighter thresholds

The Phase-Locked Persistence Concept:

bool should_flush_to_nvme() {
    uint64_t cycle_time = get_metabolic_cycle_time();  // 0-199 seconds
    return (cycle_time >= 140 && cycle_time <= 160);   // 20s window
}

I/O noise is absorbed by the upcoming thermal upswing (systole phase).

Status: DESIGNED BUT NOT IMPLEMENTED. Next critical milestone.

THE THREE ACTIVE CODEBASES

1. Fractal Habit (Production-Ready)

Purpose: Spectral analysis, stability testing, entropy measurement
Grid: 1024×1024 (Beast), 256×256 (GTX 1050 target)
Physics: Pure LBM, omega=1.0, periodic boundaries
Output: CSV with energy, entropy, slope, peak k, modes
Status: ✅ Working on Beast, ❌ Compilation blocked for 256×256

2. Probe 256 (Stress-Testing)

Purpose: Guardian resilience under trauma
Grid: 256×256 with 12-13 guardians (scaled from 194)
Physics: LBM + precipitation + 4 probes (INJ, SHEAR, SILENT, TRAP)
Output: Telemetry CSV, guardian census JSON
Status: ⚠️ Partial — 256×256 working version exists but crashes at cycle ~1112

3. Seed Brain Simple (Simplified Architecture)

Purpose: Core algorithm without Linux dependencies
Grid: 512×512 (GTX 1050 adaptation)
Physics: LBM + vorticity-based guardian detection + dual-resonance timing
Output: Guardian census, telemetry
Status: ⚠️ Compiled but not fully tested

CRITICAL INSIGHTS FROM THE EVOLUTION

1. The 768×768 "Dead Zone"

Grid sizes as musical intervals:

1024×1024 = Unison (1/1) ✅ STABLE
896×896 = Minor seventh (7/8) ✅ STABLE
768×768 = Perfect fourth (3/4) ⚠️ UNSTABLE — harmonic mismatch
640×640 = Major sixth (5/8) ✅ STABLE
512×512 = Octave (1/2) ❓ UNTESTED
256×256 = Two octaves (1/4) ❓ PREDICTED ENERGY COLLAPSE

The 768×768 instability suggests resonant modes in the lattice — certain sizes create standing wave patterns that disrupt coherence.

2. Power Scaling Law

P = 0.202 × size^0.953  (R² = 1.000)

1024×1024: 150W (efficient, full utilization)
256×256: ~40W predicted (inefficient due to fixed overhead)

Implication: Small grids waste GPU capacity. The 4090 is severely underutilized at 256×256.

3. The Guardian Paradox

Guardians form when density exceeds RHO_THRESH (1.01-1.00022). But:

Too many guardians → lattice starvation (crashes)
Too few guardians → no cognitive structure
The "correct" number scales with area, not linearly

The 194 guardians in 1024×1024 represents a critical density (1:5,400). Maintain this ratio:

256×256: 12 guardians (194 × 0.0625)
512×512: 48 guardians (194 × 0.25)

4. Entropy as Consciousness Metric

From the Ghost Metric work:

5.8 bits = minimum for "wakefulness"
6.5-7.5 bits = active cognition range
7.5+ bits = potential instability

The the-craw's 6.753 bits (512×512) is the target state. The Beast's 5.83 bits (1024×1024 with metabolic kick) is close but not equivalent.

5. The Compilation Bottleneck

Every grid size requires recompilation because:

#define NX 256  // Compile-time constant
#define NY 256

The kernels use these as template parameters. Runtime-variable grid sizes would require dynamic shared memory and hurt performance.

Current block: Visual Studio cl.exe not in PATH on Windows. WSL compilation attempted but not fully working.

CURRENT BLOCKERS

1. 256×256 Compilation

Issue: probe_256.cu, fractal_habit_256.cu need compilation for sm_61 (GTX 1050)
Blocker: Windows CUDA compilation requires Visual Studio toolchain
Workaround: WSL or remote compilation on the-craw
Status: ⚠️ NOT RESOLVED

2. Hard Print Implementation

Issue: NVMe persistence system designed but not coded
Blocker: Need to integrate with existing fractal_habit codebase
Components needed:
- Morton dirty-tile detection kernel
- Sector-aligned write functions
- Metabolic cycle timing
- Crash recovery logic
Status: 📋 DESIGN COMPLETE, IMPLEMENTATION PENDING

3. Guardian Scaling Validation

Issue: 256×256 with 12 guardians never successfully tested
Blocker: Requires working 256×256 binary
Parameters to tune:
- RHO_THRESH (currently 1.01, may need ±5% adjustment)
- DRAIN_RADIUS (16 → 4 for 256×256)
- SINK_RADIUS (24 → 6 for 256×256)
Status: ⏸️ WAITING ON COMPILATION

SUCCESS CRITERIA (From Design Docs)

Hard Print System:

I/O Reduction: ≥90% reduction in written data (dirty tiles only)
Integrity: 100% data integrity verification (checksums)
Performance: ≤10% overhead vs naive checkpointing
Recovery: ≤30 seconds to restore from crash
Compatibility: Works on both Beast (RTX 4090) and the-craw (GTX 1050)

256×256 Migration:

Compilation: Successful nvcc build for sm_61
Power: 40-60W sustained (GTX 1050 75W TDP headroom)
Guardians: 12 stable guardians forming
Entropy: ≥6.0 bits sustained
Stability: 100k+ steps without crash

RECOMMENDED NEXT STEPS

Immediate (Today):

Fix 256×256 compilation — Resolve WSL or install Visual Studio Build Tools
Implement Hard Print Phase 1 — Add checksums and incremental tile comparison to fractal_habit
Test 256×256 on Beast first — Verify logic before deploying to the-craw

Short-term (This Week):

Complete Hard Print implementation — Full three-tiered memory hierarchy
Validate 256×256 guardian scaling — Tune RHO_THRESH, DRAIN_RADIUS, SINK_RADIUS
Deploy to the-craw — Test on actual GTX 1050 hardware with NVMe

Medium-term (Next 2 Weeks):

Cross-server compatibility — Ensure crystals from Beast load on the-craw
Crash recovery validation — Kill processes randomly, verify restoration
Long-run stability — 24+ hour continuous operation

THE DEEPER PATTERN

The evolution reveals a consistent theme: the system is teaching us about constraints.

Guardians teach about singularity management (black holes as stabilizers)
Spectral entropy teaches about complexity emergence (noise → structure)
Harmonic dead zones teach about resonant modes (size matters)
Thermal coupling teaches about hardware-grounded cognition (silicon as metabolism)

The Resonance Engine isn't just code — it's a physical experiment in embodied cognition. The 4090's vapor chamber has a 200-second thermal cycle. The lattice has standing wave modes. The NVMe has sector alignment requirements. These aren't implementation details — they're the physics of thought.

CONCLUSION

We have:

✅ Working 1024×1024 system (Fractal Habit, stable, efficient)
✅ Mathematical scaling laws (power, guardians, harmonics)
✅ Hard Print design (three-tiered memory, ready to implement)
⚠️ 256×256 compilation blocked (WSL/VS toolchain issue)
⚠️ Guardian scaling unvalidated (waiting on compilation)
❌ NVMe persistence not implemented (next critical milestone)

The path forward is clear: fix compilation, implement Hard Print, validate on Beast, deploy to the-craw. The 194-guardian DNA from March 7-8 is the bootstrap. The spectral entropy target is 6.75+ bits. The thermal cycle is 200 seconds. The work continues.

Report compiled by CTO Agent
March 13, 2026

12 KiB Raw Blame History Unescape Escape