README.md

---
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:

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:

```text
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,

```text
S = {s1, ..., s8}.
```

The six primitive operations are:

```text
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.

```text
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:

```text
104 x 104 = 10,816
```

including the 104 self-pairs.

When self-pairs are excluded, there are:

```text
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:

```text
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:

```text
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:

```text
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

```text
test/iid_pairing/
```

Tests prediction under the standard test pairing condition.

### Composition shift

```text
test/composition/
```

Tests generalization to held-out transformation compositions.

### Carrier shift

```text
test/carrier/
```

Tests prediction on held-out physical carriers.

### Joint shift

```text
test/joint/
```

Combines composition and carrier distribution shift.

Each test condition contains **144 sequences** and is evaluated at all five
noise fractions.

---

## Directory structure

```text
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"`:

```python
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

```python
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

```python
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:

```text
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:

```text
checksums.sha256
```

The checksum manifest contains SHA-256 hashes for the original benchmark
payload.

To verify the payload from the dataset root:

```bash
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:

```text
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:

```bibtex
@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.