Fully Unified Model (FUM) - Historical Model Lab

Neuroca Research

This repository is a central place to inspect, run, compare, and experiment with three surviving repository states from the Fully Unified Model (FUM) generation of my research.

FUM was not one frozen codebase. It developed across several repositories. The three states preserved here show that progression:

AMN
 ↓
FUM generation
 ├── 01. FUM Demo
 ├── 02. early FUM tests
 └── 03. Fully Unified Model
 ↓
FUVDM - Fully Unified Void Dynamics Model
 ↓
VDM

The ordering above is the intended research chronology. Archive/export timestamps are not used to redefine it.

FUVDM and VDM are later generations and are not included here. The short-lived FUVDM name stood for Fully Unified Void Dynamics Model before "Fully Unified" was dropped and the research continued as VDM.

What this repository is for

The original GitHub repositories remain useful historical sources. This Hugging Face repository puts the three FUM-era states in one place so that people can:

• run the early FUM demo;
• reproduce the dedicated FUM mechanism tests;
• inspect how the architecture expanded across the generation;
• compare early and later versions of SIE, topology analysis, plasticity, and graph mechanisms;
• build new experiments against the old models without confusing them with current FUVDM/VDM technology.
• browse historical run figures, logs, and the signature structure that later became the Neuroca logo.

The original files inside each variant are preserved as repository artifacts. The top-level files here provide navigation and experiment guidance; they do not rewrite the original variant READMEs.

Signature emergence

One of the defining moments in the FUM generation was the first time I saw the model self-organize into something that was obviously organized.

Up to that point I had seen complex outputs and interesting network behavior. This structure was different. Its organization was visually clear enough that it became a turning point in how I understood the project.

That same form later became the basis for Neuroca's logo.

The image is preserved here as a historical output and developmental milestone, not as a standalone proof claim. The full visual lineage, including the later Neuroca banner, is in the gallery.

Historical gallery

The repository also includes a curated gallery/ of old FUM figures, spike rasters, dashboards, run logs, and assessment outputs.

The gallery is useful because it exposes the generation as it actually behaved across experiments rather than only through source code. The preserved logs include changing substrate sizes, SIE signals, VGSP/RE-VGSP updates, topology metrics, ADC domain cartography, GDSP/homeostatic cycles, memory accounting, input-distribution checks, and runs ranging from small Phase-1 experiments through 8,000-synapse / 10,000-stimulus trials.

Gallery filenames have been normalized for navigation. gallery/GALLERY_MANIFEST.csv maps each normalized artifact back to its original gallery/source name and SHA-256.

The three FUM variants

Variant	What it represents	Best starting point	Runtime status
01_FUM_Demo	Earliest compact FUM proof-of-concept: graph-based LIF network, SIE-modulated learning, TDA, structural plasticity, changing environment	demo.py	Runnable in principle after dependencies; current validation environment was missing ripser
02_early_FUM_tests	Experimental expansion and mechanism-validation workbench: SIE stability, KG-TDA, emergent neurons, structural homeostasis, VGSP/REVGSP-era work, Void Debt experiments	main.py	SIE path executed successfully in current validation; KG-TDA reaches ripser dependency
03_Fully_Unified_Model	Architectural consolidation: full written model, knowledge graph, adaptive domain clustering, phase-transition/scaling concepts, and training scaffold	How_It_Works/0_Table_of_Contents.md	Mixed: substantial source/tests/docs, but several phase runner files are placeholders and GPU code expects external build artifacts

See VARIANT_MAP.md for a more detailed progression map.

Quick start

Use a separate virtual environment for each variant. The repositories were developed at different moments and should not be forced into one dependency environment unless that is itself the experiment.

1 - FUM Demo

cd variants/01_FUM_Demo
python3 -m venv .venv
source .venv/bin/activate
python -m pip install -r requirements.txt
python demo.py

This is the smallest place to start if you want to watch the FUM-era mechanisms interact in one simulation.

The demo includes:

• LIF-style spiking units;
• a graph substrate;
• Self-Improvement Engine feedback;
• STDP modulation;
• topological analysis;
• structural rewiring;
• a changing GridWorld environment;
• network and spike visualizations.

The preserved README inside the variant contains the original description of the demo.

2 - early FUM tests

cd variants/02_early_FUM_tests
python3 -m venv .venv
source .venv/bin/activate
python -m pip install -r requirements.txt

The repository exposes several entry points:

# Dedicated SIE stability experiment
python main.py --sie

# Knowledge-graph / topological analysis
python main.py --kgtda

# The expanded FUM demo in this repository
python main.py --fum

# SIE + KG-TDA validation paths
python main.py --all

--all runs the two validation suites; it does not include --fum.

During preparation of this central repository, python main.py --sie completed successfully in the available environment. A 10,000-step run completed, wrote its result artifacts, and the analyzer reported bounded weight growth and converged average state for that run. The KG-TDA path successfully generated graph snapshots and then stopped because ripser was not installed in the validation environment.

This variant is the best place to experiment with individual mechanisms rather than only the integrated demo.

3 - Fully Unified Model

Start with the architecture rather than assuming this is a drop-in replacement executable for the earlier demo:

variants/03_Fully_Unified_Model/
├── Fully_Unified_Model.pdf
├── How_It_Works/
├── mathematical_frameworks/
├── planning_outlines/
└── _FUM_Training/

Recommended reading entry point:

variants/03_Fully_Unified_Model/How_It_Works/0_Table_of_Contents.md

The _FUM_Training tree contains real implementation work alongside unfinished scaffold. In particular:

• the model and neuron source contains concrete GPU/SNN implementation work;
• the tests contain substantive tests alongside placeholder files;
• scripts/run_phase1.py, run_phase2.py, run_phase3.py, and benchmark.py are preserved placeholder stubs;
• _FUM_Training/src/model/fum.py expects a compiled lif_kernel.so and a specific GPU device arrangement.

Treat this repository state as the architectural consolidation and implementation frontier of the FUM generation, not as a claim that every planned training phase was complete.

What changed across the FUM generation?

The three repositories expose a useful progression in emphasis:

integrated proof of concept
        ↓
mechanism isolation + validation + discovery
        ↓
full architecture + scaling/training program

Some of the most useful threads to follow across all three are:

Self-Improvement Engine (SIE)

• Demo: integrated feedback/modulation mechanism.
• early FUM tests: dedicated multi-objective stability experiments and parameter studies.
• Fully Unified Model: SIE becomes a first-class architectural component with extensive written treatment and mathematical-framework material.

Graph / topology

• Demo: graph substrate plus TDA inside the running simulation.
• early FUM tests: topology becomes an explicit measurement program through Knowledge Graph TDA.
• Fully Unified Model: the Unified Knowledge Graph becomes a central architectural substrate rather than only an analysis target.

Plasticity and structural change

• Demo: STDP and structural rewiring are integrated directly into the simulation.
• early FUM tests: structural homeostasis, emergent-neuron work, VGSP/REVGSP-era experimentation, persistence, and related mechanisms are isolated and explored.
• Fully Unified Model: neural and structural plasticity are integrated into the larger architecture and training/scaling design.

From FUM toward Void Dynamics

The middle FUM repository explicitly contains Void Dynamics-related discovery material, including Plots/FUM_Void_Debt_Modulation.py, and its documentation describes the discovery of Void Dynamics Theory through FUM development. That is part of the bridge out of the FUM generation.

The next generation is FUVDM, not another variant inside this repository.

Suggested experiments

See EXPERIMENTS.md for concrete experiments, but good starting points include:

1. SIE ablation across variants - compare fixed modulation, Demo-era SIE, and the dedicated early-FUM SIE analysis under matched inputs/seeds.
2. Topology instrumentation - export graph states from the Demo and analyze them with the later KG-TDA tools.
3. Plasticity ablation - disable structural rewiring, STDP, SIE modulation, or homeostatic terms one at a time.
4. Environment-switch response - measure recovery before and after the Demo's environment change.
5. Cross-variant graph metrics - apply the early-FUM topology analysis to graph snapshots produced by the Demo.
6. Reproducibility sweep - run identical configurations across many random seeds and report distributions rather than a single trajectory.
7. Complete an unfinished frontier - implement one of the preserved placeholder phase runners in the Fully Unified Model training scaffold without changing the historical source; put the implementation in a separate experiment directory.

Preserve the originals when experimenting

A useful workflow is:

cp -a variants/01_FUM_Demo experiments/my_fum_demo_experiment

Then modify only the copy. This keeps the historical snapshots readable while allowing unrestricted experimental work around them.

If you publish results, identify the exact source variant and commit/snapshot ID from PROVENANCE.json.

Experimentation permission and later-generation boundary

These historical FUM snapshots are being centralized specifically so people can inspect and experiment with them. See EXPERIMENTATION_NOTICE.md for the scope of that permission and the distinction from later FUVDM/VDM technology.

The important boundary is:

Permission to experiment with the exact historical FUM variants in this repository does not imply that later FUVDM or VDM implementations with related names or ancestry are the same mechanisms, or that those later artifacts are licensed by this repository.

Verification performed during centralization

• All Python sources in all three variants passed Python bytecode compilation.
• 02_early_FUM_tests/main.py --help executed successfully.
• 02_early_FUM_tests/main.py --sie executed successfully in the validation environment.
• The early-FUM KG snapshot generator executed successfully; TDA analysis then stopped on the missing ripser dependency.
• The earliest FUM Demo likewise reached its TDA import and stopped on missing ripser in the validation environment.
• The Fully Unified Model training scaffold was inspected for executable versus placeholder surfaces; no claim of complete end-to-end training is made here.

Provenance

The three source archives used to construct this central repository are recorded in PROVENANCE.json with their archive SHA-256 values and source commit identifiers.

No archive timestamp is used to override the author-supplied generation order.

Where this sits in the larger research lineage

Adaptive Modular Network (AMN)
        ↓
Fully Unified Model (FUM)
  ├─ FUM Demo
  ├─ early FUM tests
  └─ Fully Unified Model
        ↓
FUVDM
(Fully Unified Void Dynamics Model)
        ↓
VDM

This repository stops at the end of the FUM generation.