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:

1. whether the underlying state can be recovered from an observation,
2. whether future observations can be predicted accurately, and
3. 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.