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