license: cc-by-4.0
language:
- en
pretty_name: ProcessMemory-104
tags:
- world-models
- representation-learning
- dynamical-systems
- scientific-machine-learning
- compositional-generalization
- semigroup
- structured-dynamics
- process-memory
- benchmark
size_categories:
- 10GB<n<100GB
Archival release
The version 1.0 archival snapshot of ProcessMemory-104 is available on Zenodo:
DOI: https://doi.org/10.5281/zenodo.22804748
The Hugging Face repository provides convenient access to the benchmark, while the Zenodo record preserves the versioned archival release used for the accompanying experiments.
ProcessMemory-104
ProcessMemory-104 is a controlled benchmark for studying a simple but important question:
When a model predicts a dynamical system well, does its internal representation also recover the process that generated the observations?
The benchmark was designed to separate three properties that are often treated as if they were the same:
- whether the underlying state can be recovered from an observation,
- whether future observations can be predicted accurately, and
- whether a learned representation recovers the underlying state-transition structure.
ProcessMemory-104 provides exact symbolic ground truth for the third question. The physical observations are generated from a finite eight-state process, and the complete transformation system induced by its primitive operations is known.
The current release corresponds to the frozen Tier-C-v4 benchmark used in our experiments.
Why this benchmark exists
Many learned dynamical models are evaluated mainly through predictive error. A model can be useful for prediction while organizing its internal representation differently from the process that produced the data.
ProcessMemory-104 makes this distinction measurable.
The benchmark combines a small, exactly known symbolic process with high-dimensional physical observations. Because the symbolic process is fully enumerated, a model can be evaluated not only by prediction error, but also by whether it recovers states, transformations, information partitions, and relations between transformations.
The benchmark is therefore intended as an auditing environment for learned dynamics rather than as a high-fidelity simulation of one particular physical material.
Benchmark at a glance
ProcessMemory-104 contains:
- 8 latent states
- 6 primitive operations
- 104 distinct transformations
- 3,144 symbolic operation sequences
- 25,152 symbolic state trajectories
- 9 information classes
- 10,816 ordered transformation pairs including self-pairs
- 10,712 ordered distinct transformation pairs
- four-channel physical fields on a 32 x 32 spatial grid
- carrier-dependent physical variation
- held-out transformations
- held-out physical carriers
- composition shift
- carrier shift
- joint distribution shift
- five observation-noise levels
The five noise fractions are:
0.0
0.1
0.25
0.5
1.0
The complete release is approximately 11 GB.
Finite process
Let the latent state space contain eight states,
S = {s1, ..., s8}.
The six primitive operations are:
identity
cycle
pair_collapse
half_collapse
parity_collapse
reset
Each primitive acts deterministically on the eight-state space.
Closing these operations under composition produces exactly 104 distinct transformations.
The complete transformation system is included in the release. This makes it possible to compare a model's learned transition structure directly with the ground-truth process.
Symbolic ground truth
The symbolic/ directory contains the exact finite-process description.
symbolic/
├── generators.json
├── semigroup_elements.csv
├── composition_table.csv
├── information_classes.csv
├── information_hasse_edges.csv
├── blackwell_relations.csv
├── sequence_catalog.csv
├── symbolic_trajectories.csv
└── transformation_history_coverage.csv
generators.json
Defines the primitive operations on the eight latent states.
semigroup_elements.csv
Contains the 104 distinct transformations generated by the primitive operations.
composition_table.csv
Contains the complete composition table for the transformation semigroup.
sequence_catalog.csv
Contains 3,144 symbolic operation sequences.
symbolic_trajectories.csv
Contains 25,152 symbolic state trajectories generated from the sequence catalog.
information_classes.csv
Contains the information-partition structure induced by the transformations.
The 104 transformations form 9 information classes.
blackwell_relations.csv
Contains pairwise information-order relations between transformations.
This file contains all ordered pairs:
104 x 104 = 10,816
including the 104 self-pairs.
When self-pairs are excluded, there are:
104 x 103 = 10,712
ordered distinct transformation pairs.
The experiments reported with ProcessMemory-104 use the 10,712 ordered distinct pairs when evaluating pairwise information-order recovery.
Physical observations
Each latent state is rendered as a four-channel spatial field:
4 x 32 x 32
The physical observation generator introduces carrier-dependent variation in morphology. Different carriers therefore provide different physical realizations of the same underlying latent state.
This makes the task different from simply recognizing eight fixed templates. A model must operate across variation in the observation process while the underlying finite-state dynamics remain unchanged.
The benchmark includes both a development set and a sealed test set.
Frozen transformation split
The 104 transformations are divided into:
| Split | Transformations |
|---|---|
| Train | 86 |
| Validation | 9 |
| Test | 9 |
The held-out transformations allow evaluation of structural generalization to transformations not used during model development.
The split is provided in:
splits/transformation_split.csv
Predictive sequence split
The balanced predictive sequence split contains:
| Split | Sequences |
|---|---|
| Train | 1,376 |
| Validation | 144 |
| Test | 144 |
Relevant files are provided in:
splits/composition_sequence_split.csv
splits/iid_balanced_sequence_split.csv
Test conditions
The frozen Tier-C-v4 test benchmark contains four conditions.
IID pairing
test/iid_pairing/
Tests prediction under the standard test pairing condition.
Composition shift
test/composition/
Tests generalization to held-out transformation compositions.
Carrier shift
test/carrier/
Tests prediction on held-out physical carriers.
Joint shift
test/joint/
Combines composition and carrier distribution shift.
Each test condition contains 144 sequences and is evaluated at all five noise fractions.
Directory structure
ProcessMemory-104/
│
├── README.md
├── LICENSE
├── VERSION
├── checksums.sha256
│
├── symbolic/
│ ├── generators.json
│ ├── semigroup_elements.csv
│ ├── composition_table.csv
│ ├── information_classes.csv
│ ├── information_hasse_edges.csv
│ ├── blackwell_relations.csv
│ ├── sequence_catalog.csv
│ ├── symbolic_trajectories.csv
│ └── transformation_history_coverage.csv
│
├── splits/
│ ├── transformation_split.csv
│ ├── composition_sequence_split.csv
│ ├── iid_balanced_sequence_split.csv
│ └── carrier_split_v4.csv
│
├── protocol/
│ ├── tier_c_v4_protocol.json
│ ├── training_protocol_v4.json
│ ├── state_morphology_regimes_v4.csv
│ ├── carrier_parameter_schema_v4.csv
│ ├── coarsening_protocol_v4.json
│ └── test_sealing_policy.json
│
├── development/
│ ├── field_bank/
│ │ ├── carrier_parameters.csv
│ │ ├── normalization.json
│ │ ├── carrier_state_fields_normalized.npy
│ │ └── carrier_state_fields_raw.npy
│ │
│ ├── train_joint/
│ │ ├── fields.npy
│ │ └── sequence_manifest.csv
│ │
│ ├── val_carrier/
│ │ ├── fields.npy
│ │ └── sequence_manifest.csv
│ │
│ ├── val_composition/
│ │ ├── fields.npy
│ │ └── sequence_manifest.csv
│ │
│ └── val_joint/
│ ├── fields.npy
│ └── sequence_manifest.csv
│
├── test/
│ ├── noise_levels.npy
│ │
│ ├── iid_pairing/
│ │ ├── fields.npy
│ │ ├── sequence_manifest.csv
│ │ └── trajectory_index.csv
│ │
│ ├── composition/
│ │ ├── fields.npy
│ │ ├── sequence_manifest.csv
│ │ └── trajectory_index.csv
│ │
│ ├── carrier/
│ │ ├── fields.npy
│ │ ├── sequence_manifest.csv
│ │ └── trajectory_index.csv
│ │
│ └── joint/
│ ├── fields.npy
│ ├── sequence_manifest.csv
│ └── trajectory_index.csv
│
└── metadata/
├── normalization_v4.json
├── development_carrier_parameters.csv
├── test_carrier_parameters.csv
├── sealed_test_artifact_manifest.csv
└── single_test_opening_ledger.json
Main data files
The largest arrays in the release are approximately:
| File | Size |
|---|---|
development/train_joint/fields.npy |
6.89 GB |
test/iid_pairing/fields.npy |
0.74 GB |
test/carrier/fields.npy |
0.74 GB |
development/val_carrier/fields.npy |
0.71 GB |
test/joint/fields.npy |
0.66 GB |
test/composition/fields.npy |
0.66 GB |
development/val_joint/fields.npy |
0.54 GB |
development/val_composition/fields.npy |
0.54 GB |
Because several arrays are large, memory-mapped loading is recommended.
Loading the physical arrays
The physical observations are stored as NumPy .npy files.
For large files, use mmap_mode="r":
import numpy as np
fields = np.load(
"development/train_joint/fields.npy",
mmap_mode="r",
)
print("shape:", fields.shape)
print("dtype:", fields.dtype)
This allows the dataset to be inspected without loading the entire multi-gigabyte array into memory.
Loading a test condition
import numpy as np
import pandas as pd
fields = np.load(
"test/joint/fields.npy",
mmap_mode="r",
)
sequences = pd.read_csv(
"test/joint/sequence_manifest.csv"
)
trajectory_index = pd.read_csv(
"test/joint/trajectory_index.csv"
)
noise_levels = np.load(
"test/noise_levels.npy"
)
print("field array:", fields.shape)
print("test sequences:", len(sequences))
print("trajectory rows:", len(trajectory_index))
print("noise levels:", noise_levels.tolist())
Loading the symbolic process
import pandas as pd
transformations = pd.read_csv(
"symbolic/semigroup_elements.csv"
)
composition = pd.read_csv(
"symbolic/composition_table.csv"
)
sequences = pd.read_csv(
"symbolic/sequence_catalog.csv"
)
relations = pd.read_csv(
"symbolic/blackwell_relations.csv"
)
print("transformations:", len(transformations))
print("symbolic sequences:", len(sequences))
print("ordered relation pairs:", len(relations))
Expected values are:
transformations: 104
symbolic sequences: 3144
ordered relation pairs: 10816
Frozen protocol information
The protocol/ directory records the configuration used to construct the
Tier-C-v4 benchmark.
It includes:
- carrier parameter definitions,
- state morphology regimes,
- coarsening protocol,
- training protocol,
- test sealing policy,
- and the final Tier-C-v4 benchmark configuration.
These files are included so that benchmark construction and experimental choices can be inspected separately from model results.
Integrity checks
The frozen benchmark payload is accompanied by:
checksums.sha256
The checksum manifest contains SHA-256 hashes for the original benchmark payload.
To verify the payload from the dataset root:
sha256sum -c checksums.sha256
The original release contains 50 checksummed payload files.
Documentation files such as README.md, LICENSE, and example loading scripts
may be added after the frozen payload and are therefore not necessarily listed
in the original checksum manifest.
Recommended evaluation questions
ProcessMemory-104 can be used for several kinds of experiments.
Predictive learning
How accurately can a model predict future physical fields under carrier, composition, noise, and joint distribution shifts?
State recovery
Does the learned representation retain information about the eight underlying states?
Transformation recovery
Do learned transition operators match the known 104-element transformation system?
Compositional generalization
Can a model recover transformations held out during development?
Information-structure recovery
Does the learned process preserve the information partitions and pairwise information-order relations induced by the ground-truth transformations?
Representation auditing
Can two models achieve similar predictive accuracy while learning substantially different internal process representations?
Intended use
ProcessMemory-104 is intended for research in areas including:
- world models,
- latent dynamics,
- representation learning,
- structured representation learning,
- compositional generalization,
- finite-state dynamics,
- semigroup learning,
- process-memory analysis,
- scientific machine learning,
- representation auditing.
The benchmark is especially suited to work that needs exact process ground truth rather than only observational prediction targets.
What this benchmark is not
ProcessMemory-104 is not intended to model one particular physical material or real-world dynamical system with high physical fidelity.
Its purpose is controlled evaluation.
The observation generator provides high-dimensional, carrier-dependent physical fields while keeping the latent process exactly known. This allows representation structure to be evaluated in a way that would be difficult in real systems where the complete generating process is unknown.
Limitations
The benchmark contains one finite process with eight latent states and six primitive operations.
Its physical observations come from one family of four-channel field generators.
Results obtained on ProcessMemory-104 should therefore not be interpreted as universal claims about predictive learning, world models, or physical dynamical systems.
The benchmark also provides unusually complete symbolic ground truth. Real scientific systems often provide only partial knowledge of their underlying process.
Version
This release is:
ProcessMemory-104
Version 1.0
Protocol: Tier-C-v4
The dataset corresponds to the frozen benchmark used in the associated study.
License
ProcessMemory-104 is released under the:
Creative Commons Attribution 4.0 International License (CC BY 4.0).
You may share and adapt the dataset, including for commercial purposes, provided appropriate credit is given.
See the LICENSE file for details.
Citation
If you use ProcessMemory-104, please cite:
@dataset{adari2026processmemory104,
author = {Adari, Karthik and Uppala, Yojitha},
title = {ProcessMemory-104: A Physical-Representation Benchmark
for Auditing Algebraic Structure in Learned Dynamics},
year = {2026},
publisher = {Zenodo},
version = {1.0},
doi = {10.5281/zenodo.22804748}
}
---
## Contact and issues
If you find a problem in the released benchmark, such as an unreadable file,
manifest inconsistency, or checksum mismatch, please report it through the
dataset repository.
Please distinguish benchmark-data issues from modeling results. The dataset
contains the frozen benchmark and its ground-truth structure; model-specific
results and checkpoints are maintained separately.