Simplify to separate within-dataset layer-16 classifiers

README.md

@@ -1,58 +1,34 @@
 ---
-pretty_name: V-JEPA 2 temporal coherence experiments
-task_categories:
-  - video-classification
-tags:
-  - temporal-coherence
-  - vjepa2
-  - reproducibility
-  - colab
+pretty_name: V-JEPA 2 layer-16 probes within each dataset
+tags: [temporal-coherence, vjepa2, colab]
 ---
 
-# V-JEPA 2: temporal coherence, from raw inputs in Colab
+# Layer 16: separate classifiers within each dataset
 
-[**Open directly in Colab**](https://colab.research.google.com/gist/UYildiz12/fa02787a1a0d611b613219cdd53fa859/temporal_coherence_colab.ipynb), choose an **L4 or A100 GPU** runtime, and select **Run all**. No Drive mount, Hugging Face token, or data-access approval is needed. Colab itself requires a Google account and an available compatible GPU. The complete study processes several thousand model inputs.
+[**Open in Colab**](https://colab.research.google.com/gist/UYildiz12/fa02787a1a0d611b613219cdd53fa859/temporal_coherence_colab.ipynb). Select **L4/A100 → Run all**. Downloads are anonymous; no Drive mount is needed.
 
-The notebook regenerates the MAT audit, initial pilot, layers 16–22/24 comparison, reversal controls, graded probes, IntPhys2 continuity transfer, broader UCF order study, and arrow-of-time/control suite. The encoder is frozen throughout, and its predictor is unused. Human ratings were not collected.
+Each task trains its **own linear classifier** on frozen layer-16 features, with training-only scaling and grouped cross-validation. Held-out scenes test whether a shared readout works within that dataset. Failure does not establish that the layer lacks the information. Classifier weights never transfer between datasets.
 
-## Contents
+| Task | Labels | Groups kept together |
+|---|---|---|
+| MAT order | Intact / shuffled, including reversals | Four source variants |
+| UCF order | Intact / shuffled, including reversals | 100 source groups |
+| UCF direction | Forward / reverse intact videos | The same 100 groups |
+| IntPhys continuity | Possible / impossible | 60 matched scenes |
 
-| File | Contents |
-|---|---|
-| `temporal_coherence_colab.ipynb` | Start-to-finish notebook with explanations and concise stage calls |
-| `runtime.zip` | Full Python implementations and fixed study protocols; no feature caches or predictions |
-| `mat_raw_frames.zip` | Lossless raw pixels and frame indices for the two supplied MAT files |
+The notebook has **7 code cells**, 169 code lines and 241 words of explanation. Pixel change is the order/continuity baseline; endpoint pixels are the direction baseline. IntPhys probing is exploratory and differs from its standard benchmark protocol. MAT sources are closely related; human coherence ratings remain unmeasured.
 
-The notebook pins an immutable revision and verifies SHA-256 checksums for its runtime and raw MAT bundle. The runtime extracts to `/content/temporal_coherence_rebuild/work/temporal_coherence` for inspection. All analysis outputs are rebuilt under `/content/temporal_coherence_rebuild/outputs/temporal_coherence`.
+**Verified on 2026-09-29:** all seven code cells completed on an NVIDIA L4 in 15 min 43 s, encoding all 1,296 inputs. Layer-16 held-out balanced accuracy: MAT order 100%, UCF order 94.6%, UCF direction 55.5%, IntPhys continuity 58.8%. These estimates alone do not establish statistical significance. Pixel change ranked intact above shuffled videos perfectly within sources, so order classification remains compatible with simple visual cues.
 
-## Raw MAT inputs
+## Files
 
-The supplied dragging and rotation files each contain 16 cells of 90 RGB frames at 570 × 570. Exact repeated frames across cells are stored once. The archive reconstructs every original cell's pixels and frame order, with a SHA-256 check for each cell. MATLAB container bytes and timestamps change on reconstruction; image content does not. The known repeated/missing frames in version 2 are preserved.
+- `temporal_coherence_colab.ipynb`: complete raw-input workflow.
+- `temporal_coherence_colab_executed.ipynb`: the same notebook with verified outputs.
+- `within_dataset_results.csv`: current probe results; `verification.json` records checks and hashes.
+- `ucf_sources.json`: fixed source selection and frame indices.
+- `mat_raw_frames.zip`: lossless original pixels and frame orders; the defective two-frame condition is excluded during analysis.
+- `archive/supervised_study/`: the previous study and its separate execution record.
 
-These are user-supplied research stimuli. Their original creator and redistribution license were not supplied, so this repository does not assert a new license for them. The archive is provided at the user's request for anonymous experiment reproduction.
+The notebook pins the [model](https://huggingface.co/facebook/vjepa2-vitl-fpc64-256), [UCF](https://huggingface.co/datasets/sayakpaul/ucf101-subset) and [IntPhys2](https://huggingface.co/datasets/facebook/IntPhys2) revisions and downloads their assets directly. Their original terms apply. The supplied MAT stimuli have no asserted redistribution license.
 
-## Upstream sources, downloaded directly
-
-| Asset | Pinned upstream revision |
-|---|---|
-| [facebook/vjepa2-vitl-fpc64-256](https://huggingface.co/facebook/vjepa2-vitl-fpc64-256) | `b3c1679b7c34d3255ef3547f27c7b226aefab26f` |
-| [sayakpaul/ucf101-subset](https://huggingface.co/datasets/sayakpaul/ucf101-subset) | `b9984b8d2a95e4a1879e1b071e9433858d0bc24a` |
-| [facebook/IntPhys2](https://huggingface.co/datasets/facebook/IntPhys2) | `a077a2f94e25889016fc6e5983cf21e2ddc25fb2` |
-
-The model weights, UCF archive, and IntPhys2 videos are fetched directly from their upstream repositories and remain subject to their original terms. IntPhys2 is used only for evaluation, without training or calibration on its labels.
-
-## What the score means
-
-Frame-order ranking, playback-direction discrimination, and physical plausibility are different tests. Good performance on synthetic shuffling does not establish a general coherence measure. Pixel baselines, held-out sources/actions, full reversals, and direction-information nulls are included to constrain the interpretation. Numerical comments from the original local run are labeled separately from newly generated tables; the notebook ends with a direct comparison.
-
-## Reproduction records
-
-The notebook saves its cold-start status, all stage logs, raw-pixel checks, feature reproduction checks, fitted readouts, predictions, package versions, and final validation record. Its final cell creates `colab_results.zip`; the raw downloads remain separate. Save the executed notebook through Colab's **File → Download → Download .ipynb** menu.
-
-## Colab validation on 27 September 2026
-
-On an NVIDIA L4, all seven experimental stages regenerated from raw inputs with **zero preexisting features or predictions**, taking approximately 37 minutes. After fixing a report cell's missing audit-file dependency, a clean kernel ran **all 34 corrected code cells with zero errors** in 9 minutes 21 seconds, reusing those newly generated features. This records the two runs explicitly; the final full-notebook run was cached.
-
-The arrow-of-time probe at layer 16 achieved **72% pair accuracy on held-out sources** (95% interval 64–80%) and **51% on held-out action categories** (42–60%); chance is 50%. The original local run gave 73% and 49%, respectively. The interpretation is unchanged: direction cues are detectable within the tested action categories, with no demonstrated transfer to new categories. The notebook also completed 100 label-permutation refits and the static/palindrome null checks.
-
-See `verification.json` for the execution receipt and `colab_observed_aot_summary.csv` for the retrieved direction metrics. The temporary runtime expired before its final executed notebook and results ZIP were downloaded. The source notebook delivered here has cleared outputs; the successful execution log and retrieved metric tables are retained locally. Run all to recreate the full output archive.
+Results, features and held-out predictions are saved to `/content/layer16_within_dataset_results.zip`.

notebook_execution.json

@@ -0,0 +1,7 @@
+{
+  "elapsed_seconds": 942.6834290027618,
+  "errors": [],
+  "executed_code_cells": 7,
+  "source_sha256": "5ad5ef99c2b96a6eba2c238cc42e6454bc62c36b7974dd44b0f946280d860f0c",
+  "executed_sha256": "518e3825593287bc1f1edf197716197e4d3712f877de194be95d51a80b3f52f6"
+}

temporal_coherence_colab.ipynb

@@ -2,1244 +2,314 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "id": "41153618",
+   "id": "54cdee01",
    "metadata": {},
    "source": [
-    "# Temporal coherence in V-JEPA 2 — complete Colab rebuild\n",
+    "# What temporal information is decodable from layer 16?\n",
     "\n",
-    "**Question:** What temporal information can simple probes read from frozen layer 16?\n",
+    "Freeze V-JEPA 2. **Train a separate linear classifier within each dataset.** Keep related videos together in held-out folds. No classifier transfers between datasets.\n",
     "\n",
-    "Select **Runtime → Change runtime type → GPU**, then **Run all**. An L4 or A100 is recommended; GPU availability is controlled by Colab. The complete experiment extracts several thousand videos and may take hours. This is the full study, including the historical pilot, layer sweep, new shuffle templates, physical transfer, broader action videos, and arrow-of-time controls.\n",
-    "\n",
-    "**No Drive mount, account token, data-access approval, or local experiment folder is required.** All inputs are publicly downloadable. The model and external videos come from pinned source revisions. The two supplied MAT files are stored as a lossless raw-frame bundle: all 32 original pixel arrays and frame orders are reconstructed and checked, including the known two-frame-condition anomaly. The bundle contains no features or predictions.\n",
-    "\n",
-    "Every readout is fitted in this runtime. The encoder stays frozen and its predictor is unused. After computation, the report recomputes metrics and presents the evidence. Historical numerical comments are explicitly labeled; generated tables and the final comparison describe this run. Small changes across GPU/software versions are possible.\n",
-    "\n",
-    "Layer 16 was selected after exploratory comparisons. Human ratings remain deferred. Study seed: **20260927**."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "09a345b3",
-   "metadata": {},
-   "source": [
-    "## A. Install and fetch the reproducible inputs\n",
-    "\n",
-    "We retain Colab's CUDA/PyTorch installation and install the small dependencies used by the experiment. Raw downloads can be reused on a second run. Derived features can also resume within the same runtime, but a fresh Colab session starts with none; the next cell records that fact.\n",
-    "\n",
-    "The downloaded runtime contains the original analysis scripts with portable paths and fonts. Keeping them in one versioned bundle makes the notebook short while preserving the full implementation for inspection under `/content/temporal_coherence_rebuild/work/temporal_coherence`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f7155f1f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os, sys, subprocess, time, json, hashlib, zipfile\n",
-    "from pathlib import Path\n",
-    "os.environ.update(HF_HUB_DISABLE_IMPLICIT_TOKEN='1', HF_HUB_DISABLE_PROGRESS_BARS='1',\n",
-    "    OMP_NUM_THREADS='4', OPENBLAS_NUM_THREADS='4', MKL_NUM_THREADS='4', MPLBACKEND='Agg')\n",
-    "subprocess.run([sys.executable, '-m', 'pip', 'install', '-q',\n",
-    "    'transformers==5.15.1', 'pillow==12.3.0', 'imageio==2.37.4', 'imageio-ffmpeg==0.6.0',\n",
-    "    'scikit-learn==1.6.1', 'opencv-python-headless==4.13.0.92', 'gdown', 'nbformat', 'nbclient'], check=True)\n",
-    "import torch\n",
-    "assert torch.cuda.is_available(), 'Select a GPU runtime, then run again.'\n",
-    "assert torch.cuda.is_bf16_supported(including_emulation=False), 'Use an L4/A100 or another GPU with native bfloat16 support.'\n",
-    "ROOT = Path('/content/temporal_coherence_rebuild')\n",
-    "DATA = ROOT/'data'\n",
-    "DATA.mkdir(parents=True, exist_ok=True)\n",
-    "STARTED = time.time()\n",
-    "print('GPU:', torch.cuda.get_device_name(), '| Python:', sys.version.split()[0], '| Torch:', torch.__version__)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ae0e8b2f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from huggingface_hub import hf_hub_download, snapshot_download\n",
-    "BUNDLE_REPO = 'Iuda/vjepa-temporal-coherence'\n",
-    "BUNDLE_REVISION = '85b6a55f474a04a36a3149c45a6d9a3598f7c981'\n",
-    "EXPECTED = {\n",
-    "    'runtime.zip': '270297d3b7b705aab8c1177f7581af435a5480f8c65571d1985068a783deef91',\n",
-    "    'mat_raw_frames.zip': '67f6e6eff15fb0eac0d5e7b7545faa2c02fcec063db038d717f424736ec25941'}\n",
-    "initial_features = list((ROOT/'outputs').rglob('*.npz'))\n",
-    "initial_predictions = list((ROOT/'outputs').rglob('*predictions*.csv'))\n",
-    "start_record = {'started_utc': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),\n",
-    "    'preexisting_feature_files': len(initial_features), 'preexisting_prediction_files': len(initial_predictions),\n",
-    "    'cold_start': not (initial_features or initial_predictions), 'anonymous_downloads': True,\n",
-    "    'bundle_revision': BUNDLE_REVISION, 'gpu': torch.cuda.get_device_name()}\n",
-    "for filename, expected in EXPECTED.items():\n",
-    "    path = Path(hf_hub_download(BUNDLE_REPO, filename, repo_type='dataset',\n",
-    "        revision=BUNDLE_REVISION, local_dir=DATA, token=False))\n",
-    "    assert hashlib.sha256(path.read_bytes()).hexdigest() == expected, filename + ' checksum mismatch'\n",
-    "with zipfile.ZipFile(DATA/'runtime.zip') as archive:\n",
-    "    assert all((ROOT/name).resolve().is_relative_to(ROOT.resolve()) for name in archive.namelist())\n",
-    "    archive.extractall(ROOT)\n",
-    "(ROOT/'logs').mkdir(exist_ok=True)\n",
-    "receipt = ROOT/'logs/cold_start.json'\n",
-    "if start_record['cold_start'] or not receipt.exists(): receipt.write_text(json.dumps(start_record, indent=2))\n",
-    "print('This invocation:', start_record)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "dd9adee7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "MODEL_REVISION = 'b3c1679b7c34d3255ef3547f27c7b226aefab26f'\n",
-    "UCF_REVISION = 'b9984b8d2a95e4a1879e1b071e9433858d0bc24a'\n",
-    "INTPHYS_REVISION = 'a077a2f94e25889016fc6e5983cf21e2ddc25fb2'\n",
-    "snapshot_download('facebook/vjepa2-vitl-fpc64-256', revision=MODEL_REVISION,\n",
-    "    local_dir=DATA/'models/vjepa2-vitl-fpc64-256', token=False,\n",
-    "    allow_patterns=['config.json', 'video_preprocessor_config.json', 'model.safetensors', 'README.md'])\n",
-    "snapshot_download('sayakpaul/ucf101-subset', repo_type='dataset', revision=UCF_REVISION,\n",
-    "    local_dir=DATA/'external_stimuli/UCF101_subset', token=False,\n",
-    "    allow_patterns=['UCF101_subset.tar.gz', 'README.md'])\n",
-    "intphys = DATA/'external_stimuli/IntPhys2'\n",
-    "snapshot_download('facebook/IntPhys2', repo_type='dataset', revision=INTPHYS_REVISION,\n",
-    "    local_dir=intphys, token=False, allow_patterns=['Main/metadata.csv', 'README.md'])\n",
-    "import pandas as pd\n",
-    "metadata = pd.read_csv(intphys/'Main/metadata.csv', keep_default_na=False)\n",
-    "paths = ['Main/'+s for s in metadata.loc[metadata.condition.eq('continuity'), 'file_name']]\n",
-    "assert len(paths) == 240\n",
-    "snapshot_download('facebook/IntPhys2', repo_type='dataset', revision=INTPHYS_REVISION,\n",
-    "    local_dir=intphys, token=False, allow_patterns=paths)\n",
-    "sys.path.insert(0, str(ROOT/'work/temporal_coherence'))\n",
-    "import colab_pipeline as pipeline\n",
-    "print('Raw inputs ready. All downloads explicitly used token=False.')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "081207bb",
-   "metadata": {},
-   "source": [
-    "## B1. Restore and audit the original stimuli\n",
-    "\n",
-    "Reconstruct the 32 original MAT cells, verify every raw pixel hash, and create deterministic 64- and 90-frame model inputs. Preview movies are for inspection only.\n",
-    "\n",
-    "Complete subprocess logs are saved under `ROOT/logs`. A failed stage raises an error; later stages require its completion receipt."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ea411ae4",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pipeline.stage('mat')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7daa4b61",
-   "metadata": {},
-   "source": [
-    "## B2. Rebuild the historical pilot\n",
-    "\n",
-    "Run the frozen encoder on the original supplied cells and additional shuffles; fit the original cross-family readouts. The supplied cells already contain shuffle levels, so this is an additional-disruption pilot.\n",
-    "\n",
-    "Complete subprocess logs are saved under `ROOT/logs`. A failed stage raises an error; later stages require its completion receipt."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "fafc0c73",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pipeline.stage('pilot')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f7db2129",
-   "metadata": {},
-   "source": [
-    "## B3. Compare layers 16–22 and 24\n",
-    "\n",
-    "Extract all requested layers in each forward pass, recover the stored shuffle orders from image content, and fit the cross-family probes with and without anomalous version 2.\n",
-    "\n",
-    "Complete subprocess logs are saved under `ROOT/logs`. A failed stage raises an error; later stages require its completion receipt."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "fb4132fd",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pipeline.stage('layers')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d3c2561d",
-   "metadata": {},
-   "source": [
-    "## B4. Test reversal tolerance and graded order\n",
-    "\n",
-    "Generate fresh exact frame permutations, preserve source-family separation, and fit the regularized ranking heads. Evaluate held-out templates and full reversals.\n",
-    "\n",
-    "Complete subprocess logs are saved under `ROOT/logs`. A failed stage raises an error; later stages require its completion receipt."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cef73bba",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pipeline.stage('graded')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a8f136b6",
-   "metadata": {},
-   "source": [
-    "## B5. Transfer frozen readouts to IntPhys2\n",
-    "\n",
-    "Evaluate the previously fitted MAT heads on all 120 native continuity pairs and predetermined controls. IntPhys2 labels never train or calibrate a readout.\n",
-    "\n",
-    "Complete subprocess logs are saved under `ROOT/logs`. A failed stage raises an error; later stages require its completion receipt."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "1ab1986b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pipeline.stage('physical')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "e87b32c7",
-   "metadata": {},
-   "source": [
-    "## B6. Repeat the controlled study on 100 UCF source groups\n",
-    "\n",
-    "Select the fixed sources, generate all order conditions, extract layer 16, and fit grouped readouts plus pixel/motion baselines. Source folds and action holdouts keep all derivatives together.\n",
-    "\n",
-    "Complete subprocess logs are saved under `ROOT/logs`. A failed stage raises an error; later stages require its completion receipt."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "0b37ed5a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pipeline.stage('broad')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b610a7a7",
-   "metadata": {},
-   "source": [
-    "## B7. Test arrow of time and related controls\n",
-    "\n",
-    "Extract new local reversals, shifts, static videos and palindromes; fit direction heads using intact forward/reverse pairs only. Run 100 refitted label permutations and evaluate the frozen order heads on the new controls.\n",
-    "\n",
-    "Complete subprocess logs are saved under `ROOT/logs`. A failed stage raises an error; later stages require its completion receipt."
+    "**Colab: L4/A100 → Run all.** Raw inputs download anonymously. All computation is below."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "ccfd5d45",
+   "id": "0613e725",
    "metadata": {},
    "outputs": [],
    "source": [
-    "pipeline.stage('direction')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a9f900bc",
-   "metadata": {},
-   "source": [
-    "## C. Inspect the regenerated evidence\n",
-    "\n",
-    "Everything below reads the outputs just produced in this Colab runtime. Numerical prose labeled **original reference run** is retained to explain the earlier study. It is not substituted for a new measurement. The final comparison puts regenerated metrics beside those references."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "19294777",
-   "metadata": {},
-   "source": [
-    "## 1. Four different meanings of “temporal”\n",
-    "\n",
-    "| Question | Operational test here | What success would establish |\n",
-    "|---|---|---|\n",
-    "| Frame-order disruption | Intact versus shuffled; longer versus shorter retained blocks | A readout detects the constructed manipulation |\n",
-    "| Temporal continuity | Sensitivity to local reversals and new boundaries | Descriptive sensitivity; no human label was collected |\n",
-    "| Arrow of time | Stored forward playback versus full reversal | Direction information accessible to the chosen readout |\n",
-    "| Physical plausibility / perceived coherence | IntPhys2 possible versus impossible events / human ratings | Transfer to that physical task / agreement with observers |\n",
-    "\n",
-    "Shuffling is a useful first proxy because it changes order while keeping the same images. Longer retained blocks usually preserve more local motion. However, shuffling also increases simple pixel differences, so success need not involve event understanding. Full reversal preserves adjacent **undirected** pixel differences and can remain smooth and coherent. It tests a different property.\n",
-    "\n",
-    "A linear probe asks whether a weighted combination of features predicts a target. It does not isolate dedicated neurons, prove causal necessity, or remove every other variable represented by the layer."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "0f7ddfbd",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-09-27T13:37:57.606588Z",
-     "iopub.status.busy": "2026-09-27T13:37:57.606588Z",
-     "iopub.status.idle": "2026-09-27T13:37:58.258972Z",
-     "shell.execute_reply": "2026-09-27T13:37:58.258972Z"
-    }
-   },
-   "outputs": [],
-   "source": [
+    "import os, sys, subprocess, json, hashlib, zipfile, tarfile, shutil\n",
     "from pathlib import Path\n",
-    "import json\n",
+    "os.environ['HF_HUB_DISABLE_IMPLICIT_TOKEN'] = '1'\n",
+    "subprocess.run([sys.executable, '-m', 'pip', 'install', '-q', 'transformers==5.15.1',\n",
+    "    'scikit-learn==1.6.1', 'opencv-python-headless==4.13.0.92'], check=True)\n",
     "import numpy as np\n",
     "import pandas as pd\n",
     "import matplotlib.pyplot as plt\n",
-    "from IPython.display import display, Image, Markdown\n",
+    "import cv2, torch\n",
+    "import torch.nn.functional as F\n",
+    "from PIL import Image\n",
+    "from huggingface_hub import hf_hub_download\n",
+    "from transformers import AutoModel\n",
+    "from sklearn.model_selection import GroupKFold\n",
+    "from sklearn.pipeline import make_pipeline\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "from sklearn.linear_model import LogisticRegression\n",
+    "from sklearn.metrics import balanced_accuracy_score, roc_auc_score\n",
     "\n",
+    "assert torch.cuda.is_available() and torch.cuda.is_bf16_supported(including_emulation=False), 'Select an L4/A100 GPU.'\n",
     "SEED = 20260927\n",
-    "BASE = ROOT/'outputs/temporal_coherence'\n",
-    "PILOT = BASE\n",
+    "torch.manual_seed(SEED)\n",
+    "torch.set_num_threads(4)\n",
+    "cv2.setNumThreads(1)\n",
+    "OUT = Path('/content/layer16_within_dataset')\n",
+    "OUT.mkdir(exist_ok=True)\n",
+    "BUNDLE_REV = 'e2076dd5e294a38a1eae370a446cf3632f2616b4'\n",
+    "MODEL_REV = 'b3c1679b7c34d3255ef3547f27c7b226aefab26f'\n",
     "\n",
-    "def csv(name): return pd.read_csv(BASE / name)\n",
-    "def saved_json(name): return json.loads((BASE / name).read_text(encoding='utf-8'))\n",
-    "pd.set_option('display.max_columns', 12)\n",
-    "print('Results:', BASE)"
+    "def download(repo, filename, revision):\n",
+    "    return Path(hf_hub_download(repo, filename, repo_type='dataset', revision=revision, token=False))"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "b5add25c",
+   "id": "ab924751",
    "metadata": {},
    "source": [
-    "## 2. What was inside the MAT files?\n",
-    "\n",
-    "Each MAT contains **16 cells**, each with 90 RGB frames at 570 × 570. There are eight block-order versions for each of two variants, giving 32 cells across dragging and rotation. Cells 8 and 16 were inferred to be intact references. The two variants are **not exact horizontal mirrors**; their precise generating relationship is unknown.\n",
+    "## 1. Shared feature extraction\n",
     "\n",
-    "The independent source material is four closely related source variants, not 32 independent scenes. Version 2 has a construction anomaly: it repeats reference frames 17–18 and omits 77–78. We retained the originals and reported sensitivity analyses excluding that version. New synthetic permutations preserve all frames exactly."
+    "Layer 16: normalize tokens, then average to 1,024 features. The encoder is frozen; the predictor is unused."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "af67e909",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-09-27T13:37:58.259977Z",
-     "iopub.status.busy": "2026-09-27T13:37:58.259977Z",
-     "iopub.status.idle": "2026-09-27T13:37:58.274862Z",
-     "shell.execute_reply": "2026-09-27T13:37:58.274862Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "audit = csv('stored_layers_16_22/recovered_conditions.csv')\n",
-    "display(audit.groupby('source_group').agg(cells=('clip_id', 'size'),\n",
-    "    intact_cells=('intact_inferred', 'sum'), min_unique_frames=('unique_frames', 'min')))\n",
-    "display(audit.query('unique_frames < 90')[['clip_id', 'unique_frames',\n",
-    "    'duplicated_reference_frames_one_based', 'missing_reference_frames_one_based']])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "4eeff9b2",
+   "id": "354241b5",
    "metadata": {},
-   "source": [
-    "The following map shows the recovered frame positions. A smooth rising run means consecutive original frames survived together. Short blocks create many discontinuities. The mapping is inferred from frame content, rather than trusted from the cell number alone."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cb7aa547",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-09-27T13:37:58.275867Z",
-     "iopub.status.busy": "2026-09-27T13:37:58.275867Z",
-     "iopub.status.idle": "2026-09-27T13:37:58.367949Z",
-     "shell.execute_reply": "2026-09-27T13:37:58.367949Z"
-    }
-   },
    "outputs": [],
    "source": [
-    "orders = saved_json('stored_layers_16_22/recovered_frame_orders.json')\n",
-    "matrix = np.array([orders['orders_by_version'][str(v)] for v in range(1, 9)])\n",
-    "fig, ax = plt.subplots(figsize=(10, 3))\n",
-    "im = ax.imshow(matrix, aspect='auto', cmap='viridis', interpolation='nearest')\n",
-    "ax.set(yticks=range(8), yticklabels=orders['block_frames_by_version'],\n",
-    "       xlabel='Playback frame position', ylabel='Retained block length')\n",
-    "fig.colorbar(im, ax=ax, label='Frame position in inferred intact reference')\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "64716a50",
-   "metadata": {},
-   "source": [
-    "## 3. What exactly is “layer 16”?\n",
+    "model = AutoModel.from_pretrained('facebook/vjepa2-vitl-fpc64-256', revision=MODEL_REV,\n",
+    "    token=False, dtype=torch.bfloat16, attn_implementation='sdpa').eval().requires_grad_(False).cuda()\n",
+    "mean = torch.tensor([.485, .456, .406], device='cuda')[None, None, :, None, None]\n",
+    "std = torch.tensor([.229, .224, .225], device='cuda')[None, None, :, None, None]\n",
+    "rows, features, pixels = [], [], []\n",
     "\n",
-    "We use `facebook/vjepa2-vitl-fpc64-256`, a 24-block encoder. Layer 16 means the output of block index 15, after its residual update. Each token receives non-affine LayerNorm (ε = 10⁻⁶); we then average spatially and temporally to get 1,024 numbers:\n",
+    "def crop(frame):\n",
+    "    image = Image.fromarray(frame)\n",
+    "    w, h = image.size\n",
+    "    image = image.resize((int(w * 292/min(w,h)), int(h * 292/min(w,h))), Image.Resampling.BILINEAR)\n",
+    "    w, h = image.size\n",
+    "    return np.asarray(image.crop(((w-256)//2, (h-256)//2, (w-256)//2+256, (h-256)//2+256)))\n",
     "\n",
-    "$$\n",
-    "x(v)=\\frac{1}{TP}\\sum_{t=1}^{T}\\sum_{p=1}^{P}\\mathrm{LayerNorm}(h^{(16)}_{t,p}(v)).\n",
-    "$$\n",
+    "def read_video(path, indices=None, count=90):\n",
+    "    cap = cv2.VideoCapture(str(path))\n",
+    "    n = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))\n",
+    "    indices = np.rint(np.linspace(0, n-1, count)).astype(int) if indices is None else np.asarray(indices)\n",
+    "    assert len(set(indices)) == len(indices) and min(indices) >= 0 and max(indices) < n\n",
+    "    wanted, frames = set(indices), []\n",
+    "    try:\n",
+    "        for i in range(max(indices)+1):\n",
+    "            ok, frame = cap.read()\n",
+    "            assert ok, f'Decode failed: {path}, frame {i}'\n",
+    "            if i in wanted: frames.append(crop(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)))\n",
+    "    finally:\n",
+    "        cap.release()\n",
+    "    return np.stack(frames)\n",
     "\n",
-    "The encoder is frozen. **The V-JEPA predictor is unused**: none of these scores is prediction error or model “surprise.” Only small readouts are fitted.\n",
-    "\n",
-    "Frames use RGB, bilinear resize of the short side to 292, a 256 center crop, and the checkpoint's normalization. MAT and IntPhys2 follow-ups use 90 frames (45 tubelets); the pilot and UCF study use 64 (32 tubelets). Each tubelet spans two frames and 256 spatial tokens. The number of frames, domain, and task therefore change across studies. Preview MP4s are never the model input."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "49202e2b",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-09-27T13:37:58.370000Z",
-     "iopub.status.busy": "2026-09-27T13:37:58.368889Z",
-     "iopub.status.idle": "2026-09-27T13:37:58.373945Z",
-     "shell.execute_reply": "2026-09-27T13:37:58.373945Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "env = saved_json('stored_layers_16_22/environment.json')\n",
-    "display(pd.Series({k: env[k] for k in ['model_repo', 'model_revision', 'model_sha256',\n",
-    "    'torch', 'transformers', 'dtype', 'gpu']}, name='Recorded value').to_frame())"
+    "@torch.inference_mode()\n",
+    "def add(frames, **record):\n",
+    "    pooled = []\n",
+    "    def capture(module, inputs, output):\n",
+    "        z = F.layer_norm(output[0].float(), (1024,), eps=model.config.layer_norm_eps)\n",
+    "        pooled.append(z.mean(1)[0].cpu().numpy())\n",
+    "    hook = model.encoder.layer[15].register_forward_hook(capture)\n",
+    "    try:\n",
+    "        x = torch.from_numpy(np.ascontiguousarray(frames)).permute(0,3,1,2)[None].cuda().float() / 255\n",
+    "        model.encoder(pixel_values_videos=((x-mean)/std).to(torch.bfloat16))\n",
+    "    finally:\n",
+    "        hook.remove()\n",
+    "    endpoints = [np.asarray(Image.fromarray(f).resize((8,8)), dtype=float) for f in frames[[0,-1]]]\n",
+    "    mae = np.abs(np.diff(frames.astype(np.float32), axis=0)).mean() / 255\n",
+    "    pixels.append(np.r_[mae, ((endpoints[1]-endpoints[0])/255).ravel()])\n",
+    "    features.append(pooled[0])\n",
+    "    rows.append(record)"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "d787c2dd",
+   "id": "62de8e7f",
    "metadata": {},
    "source": [
-    "## 4. Historical pilot: additional shuffling\n",
-    "\n",
-    "The first pilot applied more shuffling to every supplied cell before we knew those cells already contained shuffle levels. Its numbers remain useful as a procedural pilot, but its “original” condition is **not a verified coherent condition**. It used final-layer pooling and 64 frames, so it is not a clean comparison of layer 24 against the later layer-16 experiments.\n",
+    "## 2. MAT: intact versus shuffled\n",
     "\n",
-    "One family trained the classifier and the other tested it. AUC measures ranking; balanced accuracy measures the fixed decision threshold. The gap between them already warned us about threshold transfer."
+    "Four related sources, 90 frames. Exclude the defective two-frame condition. Intact forward and reversed videos share the positive label."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "d2257c63",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-09-27T13:37:58.375255Z",
-     "iopub.status.busy": "2026-09-27T13:37:58.373945Z",
-     "iopub.status.idle": "2026-09-27T13:37:58.382287Z",
-     "shell.execute_reply": "2026-09-27T13:37:58.382287Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "pilot = pd.read_csv(PILOT / 'cross_family_metrics.csv')\n",
-    "display(pilot.groupby(['task', 'method'])[['auc', 'balanced_accuracy']].mean().round(3))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "22f86068",
+   "id": "ae9acd07",
    "metadata": {},
-   "source": [
-    "> **Original reference run:** numerical commentary below describes the earlier local run. Generated tables/plots show this Colab run; compare them in section D.\n",
-    "\n",
-    "**Comment:** The final-layer frame-shuffle probe had good ranking but 50% balanced accuracy. The corrected interpretation is additional-disruption sensitivity. We do not count this as evidence of a general coherence classifier.\n",
-    "\n",
-    "## 5. Exploratory layers 16–22, with layer 24 as a reference\n",
-    "\n",
-    "The follow-up used the stored 90-frame versions and evaluated intact versus shuffled across drag/rotate families. The table compares normalized features, first with all cells and then excluding anomalous version 2. This is exploratory layer selection on tiny, related source material."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "33b24e85",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-09-27T13:37:58.383300Z",
-     "iopub.status.busy": "2026-09-27T13:37:58.383300Z",
-     "iopub.status.idle": "2026-09-27T13:37:58.405339Z",
-     "shell.execute_reply": "2026-09-27T13:37:58.405339Z"
-    }
-   },
    "outputs": [],
    "source": [
-    "layers = csv('stored_layers_16_22/layer_summary.csv')\n",
-    "display(layers.query(\"method == 'token_norm'\").pivot(index='layer', columns='exclude_2frame',\n",
-    "    values='balanced_accuracy').rename(columns={False: 'All cells', True: 'Exclude version 2'}).mul(100).round(2))\n",
-    "display(Image(filename=str(BASE / 'stored_layers_16_22/layer16_focus.png'), width=900))"
+    "bundle = download('Iuda/vjepa-temporal-coherence', 'mat_raw_frames.zip', BUNDLE_REV)\n",
+    "assert hashlib.sha256(bundle.read_bytes()).hexdigest() == '67f6e6eff15fb0eac0d5e7b7545faa2c02fcec063db038d717f424736ec25941'\n",
+    "blocks = [1, 2, 3, 6, 9, 15, 18, 90]\n",
+    "with zipfile.ZipFile(bundle) as archive:\n",
+    "    for source in json.loads(archive.read('manifest.json'))['sources']:\n",
+    "        raw = np.load(archive.open(source['family'] + '_frames.npy'), allow_pickle=False)\n",
+    "        small = np.stack([crop(frame) for frame in raw])\n",
+    "        for clip in source['clips']:\n",
+    "            i, ids = clip['cell']-1, clip['indices']\n",
+    "            assert hashlib.sha256(raw[ids].tobytes()).hexdigest() == clip['pixel_sha256_THWC']\n",
+    "            if i % 8 == 1: continue\n",
+    "            reference = source['clips'][7 + 8*(i//8)]['indices']\n",
+    "            assert len(set(ids)) == 90 and sorted(ids) == sorted(reference)\n",
+    "            name = source['family'] + '_' + ('A' if i < 8 else 'B')\n",
+    "            block = blocks[i % 8]\n",
+    "            for forward in [1, 0]:\n",
+    "                frames = small[ids][::1 if forward else -1]\n",
+    "                add(frames, dataset='MAT', source=name, pair=name, block=block,\n",
+    "                    intact=int(block == 90), forward=forward)\n",
+    "print('MAT:', sum(r['dataset'] == 'MAT' for r in rows), 'inputs')"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "7c9b90aa",
+   "id": "a0a789fc",
    "metadata": {},
    "source": [
-    "> **Original reference run:** numerical commentary below describes the earlier local run. Generated tables/plots show this Colab run; compare them in section D.\n",
-    "\n",
-    "**Comment:** Layer 16 reached 98.21% balanced accuracy (31/32 correct predictions), falling to 93.75% when version 2 was excluded and the probes refitted. Layer 20 led that sensitivity analysis at 95.83%. Every tested layer and the pixel baseline had AUC 1.0 within each held-out family. Thus layer 16 was a useful working choice, not an independently confirmed optimum.\n",
+    "## 3. UCF: order and arrow of time\n",
     "\n",
-    "Distance from the matching intact representation also ordered disruption levels well. That measure requires an intact reference; it cannot directly score an arbitrary video on its own. Pixel MAE ordered these levels perfectly too."
+    "100 sources, 64 frames. Order uses intact/block-shuffled videos in both directions. A separate direction classifier uses only intact forward/reverse pairs."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "3b2d8dc6",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-09-27T13:37:58.406566Z",
-     "iopub.status.busy": "2026-09-27T13:37:58.406566Z",
-     "iopub.status.idle": "2026-09-27T13:37:58.414226Z",
-     "shell.execute_reply": "2026-09-27T13:37:58.414226Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "distance = csv('stored_layers_16_22/distance_order_correlations.csv')\n",
-    "display(distance.query('layer == 16').groupby('exclude_2frame')[\n",
-    "    'spearman_disruption_vs_distance'].mean().rename('Mean Spearman rho').to_frame())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "24492faf",
+   "id": "3fff97a2",
    "metadata": {},
-   "source": [
-    "## 6. Does reversing a coherent movement confuse the existing probe?\n",
-    "\n",
-    "We froze the original binary probe, reproduced its earlier logits, and reversed the four inferred intact clips. No reversed clip entered this probe's training. The control is useful because dragging and rotation can remain coherent backward."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6920e066",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-09-27T13:37:58.416233Z",
-     "iopub.status.busy": "2026-09-27T13:37:58.416233Z",
-     "iopub.status.idle": "2026-09-27T13:37:58.429119Z",
-     "shell.execute_reply": "2026-09-27T13:37:58.429119Z"
-    }
-   },
    "outputs": [],
    "source": [
-    "reversal = csv('layer16_probe_validation/intact_reversal_controls.csv')\n",
-    "display(reversal.query('exclude_2frame == False')[['clip_id', 'forward_logit', 'reverse_logit',\n",
-    "    'forward_predicted_intact', 'reverse_predicted_intact']].round(3))\n",
-    "display(csv('layer16_probe_validation/binary_reversal_metrics.csv').round(3))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "aa37ca03",
-   "metadata": {},
-   "source": [
-    "> **Original reference run:** numerical commentary below describes the earlier local run. Generated tables/plots show this Colab run; compare them in section D.\n",
-    "\n",
-    "**Comment:** All four intact reversals were accepted by the existing probe without reverse training. This supports reversal tolerance on these four stimuli. It does not show that all backward events are physically plausible, or that every layer feature is reversal-invariant.\n",
-    "\n",
-    "## 7. A graded probe, with fresh shuffle templates\n",
-    "\n",
-    "We generated four exact shuffle templates per level from the same four sources: two templates for training and two for evaluation, with whole action families held out. Both playback directions were included. A linear score ranks larger retained blocks above smaller blocks; equal spacing between levels is not assumed."
+    "selection = json.loads(download('Iuda/vjepa-temporal-coherence', 'ucf_sources.json', BUNDLE_REV).read_text())\n",
+    "archive_path = download('sayakpaul/ucf101-subset', 'UCF101_subset.tar.gz', 'b9984b8d2a95e4a1879e1b071e9433858d0bc24a')\n",
+    "assert hashlib.sha256(archive_path.read_bytes()).hexdigest() == 'e9fcc76af48d320be88c5265f2e0576ecd615956976f6ce4742fdf2b042b71eb'\n",
+    "with tarfile.open(archive_path) as archive:\n",
+    "    for i, source in enumerate(selection, 1):\n",
+    "        path = OUT.parent/'source.avi'\n",
+    "        path.write_bytes(archive.extractfile(source['archive_member']).read())\n",
+    "        assert hashlib.sha256(path.read_bytes()).hexdigest() == source['source_sha256']\n",
+    "        video = read_video(path, source['sampled_indices'])\n",
+    "        rng = np.random.default_rng(int(hashlib.sha256((str(SEED)+source['source_id']).encode()).hexdigest()[:8], 16))\n",
+    "        for block in [1, 4, 8, 16, 64]:\n",
+    "            order = np.arange(64)\n",
+    "            if block < 64:\n",
+    "                while np.array_equal(order, np.arange(64)):\n",
+    "                    order = np.arange(64).reshape(-1,block)[rng.permutation(64//block)].ravel()\n",
+    "            for forward in [1, 0]:\n",
+    "                add(video[order][::1 if forward else -1], dataset='UCF', source=source['group_id'],\n",
+    "                    pair=source['group_id'], block=block, intact=int(block == 64), forward=forward)\n",
+    "        if i % 10 == 0: print(f'UCF: {i}/100 sources')"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "4ecb1d48",
+   "id": "f13c1188",
    "metadata": {},
    "source": [
-    "For standardized training features $z$, the ranking objective is:\n",
-    "\n",
-    "$$\n",
-    "\\mathcal L(w)=\\operatorname{mean}_{(i,j)}\\log(1+e^{-w^\\top(z_i-z_j)})\n",
-    " +\\tfrac12\\|w\\|^2\n",
-    " +\\operatorname{mean}_{v}\\big[w^\\top(z_v-z_{v^R})\\big]^2.\n",
-    "$$\n",
+    "## 4. IntPhys: possible versus impossible\n",
     "\n",
-    "The first term rewards the requested order; the second regularizes the readout; the third encourages reversal consistency. Both penalty coefficients were fixed at 1. Training means at full shuffle and intact anchor scores to 0 and 1; scores remain unbounded and are not probabilities. A comparison omits the final penalty while retaining reversed training examples."
+    "240 continuity videos, 60 matched scenes. Fit a new probe using scene-held-out folds. This is an exploratory representation test, separate from the benchmark's standard protocol."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "be2200be",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-09-27T13:37:58.430130Z",
-     "iopub.status.busy": "2026-09-27T13:37:58.430130Z",
-     "iopub.status.idle": "2026-09-27T13:37:58.440024Z",
-     "shell.execute_reply": "2026-09-27T13:37:58.440024Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "graded = csv('layer16_probe_validation/graded_summary.csv')\n",
-    "display(graded[['method', 'evaluation', 'pairwise_accuracy', 'spearman_mean_by_level',\n",
-    "    'spearman_shuffled_levels', 'intact_auc']].round(4))\n",
-    "display(csv('layer16_probe_validation/graded_reversal_summary.csv').round(4))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f96857eb",
+   "id": "b40053de",
    "metadata": {},
-   "source": [
-    "> **Original reference run:** numerical commentary below describes the earlier local run. Generated tables/plots show this Colab run; compare them in section D.\n",
-    "\n",
-    "**Comment:** On new held-out templates, layer 16 ranked levels correctly 98.98% of the time; the pixel-only probe reached 100%. Reversal regularization slightly reduced the score gap without improving ranking. New permutations test template dependence, but they do not add new actors or scenes. The original stored-version evaluation excluded faulty version 2."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5c2cc2e3",
-   "metadata": {},
-   "source": [
-    "## 8. Outside stimuli: frozen transfer to IntPhys2\n",
-    "\n",
-    "We applied the already fitted MAT readouts to the complete selected IntPhys2 continuity subset: **240 clips, 60 scenes, 120 native possible/impossible pairs**, across eight task families. No IntPhys2 labels trained or calibrated a probe. The two MAT heads were averaged using their original sign.\n",
-    "\n",
-    "This is a harder test of the readout's scope: object continuity violations are different from deliberately shuffled video. Each clip is sampled to 90 frames across roughly 10.6–14.6 seconds, whereas the MAT clips cover about three seconds under the assumed preview rate. Domain and time sampling are additional changes."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "802a9302",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-09-27T13:37:58.441036Z",
-     "iopub.status.busy": "2026-09-27T13:37:58.441036Z",
-     "iopub.status.idle": "2026-09-27T13:37:58.471684Z",
-     "shell.execute_reply": "2026-09-27T13:37:58.470592Z"
-    }
-   },
    "outputs": [],
    "source": [
-    "physical = csv('external_intphys2/summary_metrics.csv')\n",
-    "main_physical = physical.query(\"scope == 'all_scenes' and input_condition == 'original'\")\n",
-    "display(main_physical.query(\"method in ['graded_ensemble', 'binary_ensemble', 'negative_pixel_mae']\")\n",
-    "    [['method', 'n_scenes', 'n_pairs', 'matched_pair_accuracy', 'ci95_low', 'ci95_high']].round(4))\n",
-    "\n",
-    "# Recompute the transfer accuracy from individual matched pairs.\n",
-    "physical_pairs = pd.read_csv(BASE / 'external_intphys2/matched_pair_predictions.csv', dtype={'SceneIndex': str})\n",
-    "display(physical_pairs.query(\"input_condition == 'original'\").groupby('method').correct.mean().round(4))"
+    "INTPHYS_REV = 'a077a2f94e25889016fc6e5983cf21e2ddc25fb2'\n",
+    "metadata = pd.read_csv(download('facebook/IntPhys2', 'Main/metadata.csv', INTPHYS_REV), keep_default_na=False)\n",
+    "metadata = metadata[metadata.condition.eq('continuity')].sort_values(['SceneIndex','type'])\n",
+    "assert len(metadata) == 240 and metadata.SceneIndex.nunique() == 60\n",
+    "for i, row in enumerate(metadata.to_dict('records'), 1):\n",
+    "    path = download('facebook/IntPhys2', 'Main/' + row['file_name'], INTPHYS_REV)\n",
+    "    pair, label = row['type'].split('_')\n",
+    "    add(read_video(path), dataset='IntPhys', source=str(row['SceneIndex']),\n",
+    "        pair=f\"{row['SceneIndex']}_{pair}\", possible=int(label == 'Possible'))\n",
+    "    if i % 40 == 0: print(f'IntPhys: {i}/240 videos')\n",
+    "df = pd.DataFrame(rows)\n",
+    "X, P = np.stack(features).astype(float), np.stack(pixels)\n",
+    "assert len(df) == len(X) == len(P) == 1296 and X.shape[1] == 1024 and np.isfinite(X).all()\n",
+    "df.to_csv(OUT/'inputs.csv', index=False)\n",
+    "np.savez_compressed(OUT/'features.npz', layer16=X, pixels=P, model_revision=MODEL_REV)"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "24d7fb90",
+   "id": "d7269e99",
    "metadata": {},
    "source": [
-    "> **Original reference run:** numerical commentary below describes the earlier local run. Generated tables/plots show this Colab run; compare them in section D.\n",
-    "\n",
-    "**Comment:** The graded MAT readout preferred the possible event in **41/120 pairs (34.17%)**, versus **57/120 (47.5%)** for negative pixel MAE. We do not flip the score's sign after seeing this result. The transfer failed under the chosen readout and protocol; this does not show that the full layer contains no physical information.\n",
+    "## 5. Train and evaluate within each dataset\n",
     "\n",
-    "Eight predetermined scenes also received shuffled and static controls. Higher apparent possible/impossible accuracy after removing natural temporal order weakens a temporal interpretation of those subset results."
+    "Fresh scaler + logistic regression in every fold; fixed C=1. All variants of a source stay together. Baseline: pixel change for order/continuity, endpoint pixels for direction."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "a2411883",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-09-27T13:37:58.473694Z",
-     "iopub.status.busy": "2026-09-27T13:37:58.472698Z",
-     "iopub.status.idle": "2026-09-27T13:37:58.488186Z",
-     "shell.execute_reply": "2026-09-27T13:37:58.488186Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "display(physical.query(\"scope == 'control_scenes' and method in ['graded_ensemble', 'binary_ensemble', 'negative_pixel_mae']\")\n",
-    "    .pivot(index='method', columns='input_condition', values='matched_pair_accuracy').mul(100).round(2))\n",
-    "display(Image(filename=str(BASE / 'external_intphys2/external_results.png'), width=900))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c97e365f",
+   "id": "0ec0c4f0",
    "metadata": {},
-   "source": [
-    "## 9. A broader controlled test: 100 UCF source groups\n",
-    "\n",
-    "We selected one clip from each of 100 source groups, ten per action, from the pinned UCF101 subset. A central window supplies 64 distinct sampled frames. The core conditions retain blocks of 1, 4, 8 or 16 frames, plus intact 64, in both directions. There are five source folds, with all derivatives of a source kept together. Core shuffle templates are disjoint across those source folds. A separate evaluation leaves an entire action category out.\n",
-    "\n",
-    "Layer-16, pixel/motion, and joint readouts use the same ranking objective. Controls include 21 pixel/motion summaries, a fixed nonlinear regressor on those summaries, negative mean pixel change, and the earlier MAT readout transferred without refitting. The predictor remains unused.\n",
-    "\n",
-    "**Why this design?** Same-image permutations control static content. Source grouping prevents nearly identical variants from crossing training and test splits. New action categories ask a stronger transfer question. Pixel baselines check whether simple discontinuity already explains the labels."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "120e7765",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-09-27T13:37:58.490201Z",
-     "iopub.status.busy": "2026-09-27T13:37:58.490201Z",
-     "iopub.status.idle": "2026-09-27T13:37:58.511743Z",
-     "shell.execute_reply": "2026-09-27T13:37:58.511743Z"
-    }
-   },
    "outputs": [],
    "source": [
-    "broad = csv('broad_layer16/out_of_fold_predictions.csv')\n",
-    "core = broad.query(\"scheme == 'source_folds' and role == 'core'\").sort_values('block_frames')\n",
-    "assert core.groupby('source_id').fold.nunique().eq(1).all()\n",
-    "display(core.groupby('fold').source_id.nunique().rename('Held-out source groups').to_frame())\n",
-    "manifest = saved_json('broad_layer16/manifest.json')\n",
-    "sources = pd.DataFrame(manifest['sources'])\n",
-    "design = {'sources': len(sources), 'source_file_hashes_unique': int(sources.source_sha256.nunique()),\n",
-    "    'input_records': len(manifest['sequences']),\n",
-    "    'unique_input_hashes': len({s['input_sha256'] for s in manifest['sequences']}),\n",
-    "    'baseline_features': len(manifest['sequences'][0]['baseline']),\n",
-    "    'fold_source_counts': sources.groupby('fold').size().to_dict()}\n",
-    "assert design['sources'] == design['source_file_hashes_unique'] == 100\n",
-    "assert sorted(design['fold_source_counts'].values()) == [20]*5\n",
-    "(BASE/'broad_layer16/design_integrity.json').write_text(json.dumps(design, indent=2))\n",
-    "display(pd.Series(design, name='Design').to_frame())"
+    "tasks = {'MAT order': ('MAT','intact'), 'UCF order': ('UCF','intact'),\n",
+    "         'UCF direction': ('UCF','forward'), 'IntPhys continuity': ('IntPhys','possible')}\n",
+    "results, predictions = [], []\n",
+    "for task, (dataset, target) in tasks.items():\n",
+    "    data = df[df.dataset.eq(dataset)]\n",
+    "    if target == 'forward': data = data[data.intact.eq(1)]\n",
+    "    idx, y, groups = data.index.to_numpy(), data[target].to_numpy(int), data.source.to_numpy()\n",
+    "    splits = list(GroupKFold(min(5, len(set(groups))), shuffle=True, random_state=SEED).split(idx, y, groups))\n",
+    "    baseline = P[idx, 1:] if target == 'forward' else P[idx, :1]\n",
+    "    for method, values in [('Layer 16', X[idx]), ('Pixels', baseline)]:\n",
+    "        scores = np.empty(len(y))\n",
+    "        for train, test in splits:\n",
+    "            assert set(groups[train]).isdisjoint(groups[test])\n",
+    "            probe = make_pipeline(StandardScaler(), LogisticRegression(C=1, class_weight='balanced', max_iter=5000))\n",
+    "            probe.fit(values[train], y[train])\n",
+    "            scores[test] = probe.decision_function(values[test])\n",
+    "        output = data.copy()\n",
+    "        output['task'], output['method'], output['label'], output['score'] = task, method, y, scores\n",
+    "        predictions.append(output)\n",
+    "        pairs = []\n",
+    "        for _, pair in output.groupby('pair'):\n",
+    "            margin = pair.loc[pair.label.eq(1),'score'].to_numpy()[:,None] - pair.loc[pair.label.eq(0),'score'].to_numpy()\n",
+    "            pairs.append(np.mean((margin > 0) + .5*(margin == 0)))\n",
+    "        results.append(dict(task=task, method=method, sources=len(set(groups)),\n",
+    "            balanced_accuracy=balanced_accuracy_score(y, scores >= 0),\n",
+    "            auc=roc_auc_score(y, scores), within_source_ranking=np.mean(pairs)))\n",
+    "results = pd.DataFrame(results)\n",
+    "predictions = pd.concat(predictions, ignore_index=True)\n",
+    "display(results.round(3))"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "14e27308",
+   "id": "a602a1fb",
    "metadata": {},
    "source": [
-    "### Recompute pair ranking, without refitting anything\n",
+    "## 6. Results\n",
     "\n",
-    "Each source/direction has five levels, hence ten ordered level pairs. A win means the less disrupted condition has the larger score; a tie counts half. Forward/reverse results are first averaged within each source, then across the 100 sources. The following short calculation uses the saved out-of-fold predictions directly."
+    "Balanced accuracy tests individual labels; within-source ranking compares matched conditions. Chance is 50%. These are held-out probe scores, not human coherence ratings."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "0cf6716f",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-09-27T13:37:58.512749Z",
-     "iopub.status.busy": "2026-09-27T13:37:58.512749Z",
-     "iopub.status.idle": "2026-09-27T13:37:58.559303Z",
-     "shell.execute_reply": "2026-09-27T13:37:58.559303Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "methods = ['layer16', 'pixel_motion', 'joint', 'motion_nonlinear', 'negative_pixel_mae', 'old_mat_probe']\n",
-    "def ranking_rate(values):\n",
-    "    i, j = np.triu_indices(len(values), k=1)\n",
-    "    gaps = np.asarray(values)[j] - np.asarray(values)[i]\n",
-    "    return np.where(gaps > 1e-12, 1, np.where(gaps < -1e-12, 0, .5)).mean()\n",
-    "\n",
-    "ranked = core.groupby(['source_id', 'direction'])[methods].agg(ranking_rate)\n",
-    "recomputed = ranked.groupby('source_id').mean().mean()\n",
-    "broad_summary = csv('broad_layer16/summary_metrics.csv')\n",
-    "recorded = broad_summary.query(\"scheme == 'source_folds' and direction == 'both' and metric == 'rank_accuracy'\")\n",
-    "assert np.allclose(recomputed, recorded.set_index('method').loc[methods, 'mean'])\n",
-    "display(recomputed.mul(100).round(3).rename('Core pair ranking (%)').to_frame())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d962ebcc",
+   "id": "1803372e",
    "metadata": {},
-   "source": [
-    "> **Original reference run:** numerical commentary below describes the earlier local run. Generated tables/plots show this Colab run; compare them in section D.\n",
-    "\n",
-    "**Comment:** Layer 16 achieves **99.95% pair ranking**, but negative pixel MAE reaches **100%**. The manipulation clearly transfers to new sources; superiority over simple pixel change is not established. The same layer-16 pair ranking holds in the action-holdout analysis.\n",
-    "\n",
-    "Pair ranking is not isolated-clip classification. A fixed score threshold of 0.5 gives only **68.125% balanced accuracy** for intact versus shuffled. It is wrong to describe the 99.95% result as 99.95% standalone coherence classification."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "52308589",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-09-27T13:37:58.561589Z",
-     "iopub.status.busy": "2026-09-27T13:37:58.561589Z",
-     "iopub.status.idle": "2026-09-27T13:37:58.567953Z",
-     "shell.execute_reply": "2026-09-27T13:37:58.567953Z"
-    }
-   },
    "outputs": [],
    "source": [
-    "is_intact = core.block_frames.eq(64)\n",
-    "classified = core.layer16.ge(.5)\n",
-    "balanced_accuracy = .5 * (classified[is_intact].mean() + (~classified[~is_intact]).mean())\n",
-    "print(f'Fixed-threshold intact/shuffled balanced accuracy: {balanced_accuracy:.3%}')\n",
-    "display(Image(filename=str(BASE / 'broad_layer16/broad_results.png'), width=1000))"
+    "ax = results.pivot(index='task', columns='method', values='balanced_accuracy').plot.bar(figsize=(9,3.5), rot=15)\n",
+    "ax.axhline(.5, color='gray', linestyle='--')\n",
+    "ax.set(ylabel='Held-out balanced accuracy', xlabel='', ylim=(0,1))\n",
+    "ax.figure.tight_layout()\n",
+    "ax.figure.savefig(OUT/'probe_results.png', dpi=160)\n",
+    "plt.show()\n",
+    "results.to_csv(OUT/'results.csv', index=False)\n",
+    "predictions.to_csv(OUT/'predictions.csv', index=False)\n",
+    "shutil.make_archive(str(OUT)+'_results', 'zip', OUT)\n",
+    "print('Saved results:', str(OUT)+'_results.zip')"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "a08ad35a",
+   "id": "d3478645",
    "metadata": {},
    "source": [
-    "> **Original reference run:** numerical commentary below describes the earlier local run. Generated tables/plots show this Colab run; compare them in section D.\n",
-    "\n",
-    "### Did matching pixel change remove the confound?\n",
-    "\n",
-    "Only five sources yielded an intact/shuffled pair within 5% on both average MAE and global RMS, too few for the intended strong comparison. A declared amendment therefore compared block-16 with block-8 permutations of the same images, chosen using pixels only. **38 sources** met the 5% tolerance (91 met 10%). The amendment was fixed before probe outcomes.\n",
-    "\n",
-    "Matching magnitudes approximately does not remove which member has slightly lower pixel change. The next table makes that residual cue visible."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b0320ff5",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-09-27T13:37:58.569959Z",
-     "iopub.status.busy": "2026-09-27T13:37:58.569959Z",
-     "iopub.status.idle": "2026-09-27T13:37:58.580757Z",
-     "shell.execute_reply": "2026-09-27T13:37:58.580757Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "matched = broad_summary.query(\"scheme == 'source_folds' and direction == 'both' and metric == 'matched_levels_5pct_accuracy'\")\n",
-    "display(matched[['method', 'n_sources', 'mean', 'ci95_low', 'ci95_high']].round(4))\n",
-    "added = csv('broad_layer16/paired_comparisons.csv')\n",
-    "display(added.query(\"scheme == 'source_folds' and metric == 'matched_levels_5pct_accuracy' and comparison in ['joint minus pixel_motion', 'layer16 minus negative_pixel_mae']\")\n",
-    "    [['comparison', 'n_sources', 'mean_difference', 'ci95_low', 'ci95_high']].round(4))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ebd04b6e",
-   "metadata": {},
-   "source": [
-    "> **Original reference run:** numerical commentary below describes the earlier local run. Generated tables/plots show this Colab run; compare them in section D.\n",
-    "\n",
-    "**Comment:** Layer 16 scores **78.95%** on the strict matched pairs; negative MAE still scores **97.37%**. Matching did not solve the confound. Adding layer 16 to the linear pixel/motion readout has a paired interval including zero. We have not demonstrated an added coherence signal beyond the strongest tested simple baseline.\n",
-    "\n",
-    "Bootstrap intervals resample source groups within actions, keeping methods paired. They condition on the fitted folds and selected actions; they do not include full retraining uncertainty or sampling entirely new action families. An all-success sample can have a zero-width bootstrap interval without implying population certainty."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "87ddfdbc",
-   "metadata": {},
-   "source": [
-    "## 10. Arrow of time: can the layer decode stored playback direction?\n",
-    "\n",
-    "This is the new experiment. We reuse the same 100 UCF sources and intact 64-frame inputs, each forward and reversed. A fixed `StandardScaler` + L2 logistic regression (`C=1`) trains on intact direction labels only. There are 80 training and 20 held-out source pairs per primary fold; action holdout trains on 90 and evaluates ten pairs.\n",
-    "\n",
-    "The primary representation is the same 1,024-dimensional pooled layer-16 vector. A secondary probe concatenates eight ordered temporal bins (8,192 values). Baselines use endpoint RGB differences, ordered low-resolution RGB bins, 21 pixel/motion statistics, and exactly reversal-invariant pixels. We copy mathematically symmetric statistics exactly within each pair so floating-point summation order cannot become a fake direction cue.\n",
-    "\n",
-    "$$\n",
-    "\\text{pair score}=\\mathbb{1}[s(v)>s(v^R)]\\quad\\text{with ties worth }1/2.\n",
-    "$$\n",
-    "\n",
-    "The operational target is stored playback direction. These UCF actions were not screened by people for a unique physical arrow; many motions can be reversible. The task is motivated by [Learning and Using the Arrow of Time](https://openaccess.thecvf.com/content_cvpr_2018/papers/Wei_Learning_and_Using_CVPR_2018_paper.pdf), but this is not a reproduction of its benchmark."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ee3fccd4",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-09-27T13:37:58.581762Z",
-     "iopub.status.busy": "2026-09-27T13:37:58.581762Z",
-     "iopub.status.idle": "2026-09-27T13:37:58.600314Z",
-     "shell.execute_reply": "2026-09-27T13:37:58.600314Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "aot = csv('temporal_diagnostics/aot_predictions.csv')\n",
-    "pairs = aot.pivot(index=['scheme', 'method', 'source_id'], columns='direction', values='logit')\n",
-    "gap = pairs.forward - pairs.reverse\n",
-    "pairs['correct'] = np.where(gap > 1e-10, 1, np.where(gap < -1e-10, 0, .5))\n",
-    "display(pairs.groupby(['method', 'scheme']).correct.mean().unstack().mul(100).round(1))\n",
-    "display(Image(filename=str(BASE / 'temporal_diagnostics/arrow_of_time.png'), width=1000))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "181d4e40",
-   "metadata": {},
-   "source": [
-    "> **Original reference run:** numerical commentary below describes the earlier local run. Generated tables/plots show this Colab run; compare them in section D.\n",
-    "\n",
-    "**Comment:** The pooled direction probe achieves **73/100 source pairs** (95% CI 65–81%) but **49/100** when an action category is held out (40–58%). The data support action-dependent direction cues, with no reliable transfer to new action categories. The temporal-bin probe achieves 56% and 43%, respectively. Its higher feature count changes capacity and regularization, so this does not isolate a causal benefit of pooling.\n",
-    "\n",
-    "Again, ranking and thresholding differ: pooled-layer individual-clip balanced accuracy is **54%** under source holdout and **46%** under action holdout. The 73% result is a comparison between matched forward/reverse members."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a0197e0c",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-09-27T13:37:58.600314Z",
-     "iopub.status.busy": "2026-09-27T13:37:58.600314Z",
-     "iopub.status.idle": "2026-09-27T13:37:58.614501Z",
-     "shell.execute_reply": "2026-09-27T13:37:58.614501Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "aot_summary = csv('temporal_diagnostics/aot_summary.csv')\n",
-    "display(aot_summary.query(\"method == 'layer16_pooled' and metric in ['pair_accuracy', 'individual_accuracy']\")\n",
-    "    [['scheme', 'metric', 'n_sources', 'mean', 'ci95_low', 'ci95_high']].round(3))\n",
-    "permutation = saved_json('temporal_diagnostics/permutation_result.json')\n",
-    "display(pd.Series(permutation, name='Primary label-swap test').to_frame())\n",
-    "display(Image(filename=str(BASE / 'temporal_diagnostics/direction_generalization.png'), width=1000))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "bcbfca5f",
-   "metadata": {},
-   "source": [
-    "> **Original reference run:** numerical commentary below describes the earlier local run. Generated tables/plots show this Colab run; compare them in section D.\n",
-    "\n",
-    "The primary label-swap test randomly flips each source's pair labels, refits all five probes, and repeats 100 times. The empirical one-sided **p = 1/101 ≈ 0.0099** is the smallest value resolvable with 100 permutations. This supports the source-holdout result, not action transfer. All other method comparisons and control families are exploratory.\n",
-    "\n",
-    "### The actual readout in a few lines\n",
-    "\n",
-    "Below we load the 200 saved intact embeddings and reproduce one primary fold. Scaling is fitted only on training sources. The held-out sources are asserted to be disjoint. The predictions must match the saved experiment before we interpret them."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cd74c9c3",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-09-27T13:37:58.615505Z",
-     "iopub.status.busy": "2026-09-27T13:37:58.615505Z",
-     "iopub.status.idle": "2026-09-27T13:37:59.517734Z",
-     "shell.execute_reply": "2026-09-27T13:37:59.515701Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "from sklearn.pipeline import make_pipeline\n",
-    "from sklearn.preprocessing import StandardScaler\n",
-    "from sklearn.linear_model import LogisticRegression\n",
-    "from scipy.optimize import OptimizeWarning\n",
-    "from threadpoolctl import threadpool_limits\n",
-    "import warnings\n",
-    "\n",
-    "intact_rows = aot.query(\"scheme == 'source_folds' and method == 'layer16_pooled'\").sort_values(['source_id', 'direction']).reset_index(drop=True)\n",
-    "def pooled_feature(row):\n",
-    "    filename = f'{row.source_id}_intact_{row.direction}.npz'\n",
-    "    with np.load(BASE / 'broad_layer16/features' / filename) as data: return data['feature']\n",
-    "X = np.stack([pooled_feature(row) for row in intact_rows.itertuples()]).astype(float)\n",
-    "y = intact_rows.original_forward.to_numpy()\n",
-    "test = intact_rows.fold.eq(0).to_numpy()\n",
-    "assert not set(intact_rows.loc[test, 'source_id']) & set(intact_rows.loc[~test, 'source_id'])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "82d664c8",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-09-27T13:37:59.521732Z",
-     "iopub.status.busy": "2026-09-27T13:37:59.520738Z",
-     "iopub.status.idle": "2026-09-27T13:37:59.680084Z",
-     "shell.execute_reply": "2026-09-27T13:37:59.679076Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "probe = make_pipeline(StandardScaler(), LogisticRegression(C=1, class_weight='balanced',\n",
-    "    solver='lbfgs', max_iter=5000, tol=1e-7, random_state=SEED))\n",
-    "with threadpool_limits(4), warnings.catch_warnings():\n",
-    "    warnings.filterwarnings('ignore', message='Unknown solver options: iprint', category=OptimizeWarning)\n",
-    "    probe.fit(X[~test], y[~test])\n",
-    "error = np.max(np.abs(probe.decision_function(X[test]) - intact_rows.loc[test, 'logit']))\n",
-    "assert error < 1e-5, f'Predictions changed: {error}'\n",
-    "print(f'Reproduced one held-out direction fold; maximum logit difference = {error:.2g}')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "bdaac30f",
-   "metadata": {},
-   "source": [
-    "## 11. Related temporal controls\n",
-    "\n",
-    "The new families were specified before their outcomes. They test how the two different heads respond outside their training manipulations. Each condition is also fully reversed; all transformations come from the same 100 sources.\n",
-    "\n",
-    "| Manipulation | Purpose | Interpretation limit |\n",
-    "|---|---|---|\n",
-    "| Reverse within 2-frame blocks | Change order within encoder tubelets, retain coarse chronology | Also changes local motion |\n",
-    "| Reverse within 8- or 16-frame blocks | Retain blocks but reverse their internal motion | No human coherence target |\n",
-    "| Circular shift by 32 frames | Change starting phase, introduce one wrap seam | Not guaranteed equally coherent |\n",
-    "| Repeat the middle frame | Remove motion | Static does not mean incoherent |\n",
-    "| Palindrome: 0…31, 31…0 | Make input identical to its full reversal | Changes the frame multiset |\n",
-    "| Existing block shuffles | Remove order at several scales | New to the direction head, seen in order-head training |\n",
-    "\n",
-    "Static and palindrome pairs are direction-information nulls: identical input must give identical scores up to numerical rounding. Inputs and features were checked for exact equality; batched dot products can differ by about 10⁻¹⁴. Our declared tie tolerance is 10⁻¹⁰. On other transformed clips, “forward” identifies the constructed pair member, not verified natural physical direction. We therefore call the result **forward-member preference**, rather than natural arrow-of-time accuracy."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "52b25a94",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-09-27T13:37:59.680084Z",
-     "iopub.status.busy": "2026-09-27T13:37:59.680084Z",
-     "iopub.status.idle": "2026-09-27T13:37:59.754149Z",
-     "shell.execute_reply": "2026-09-27T13:37:59.753115Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "control_predictions = csv('temporal_diagnostics/direction_control_predictions.csv')\n",
-    "control_pairs = control_predictions.pivot(index=['scheme', 'method', 'condition', 'source_id'],\n",
-    "    columns='direction', values='logit')\n",
-    "null_pairs = control_pairs.reset_index().query(\"condition in ['repeat_middle', 'palindrome']\")\n",
-    "assert np.allclose(null_pairs.forward, null_pairs.reverse, atol=1e-10, rtol=0)\n",
-    "print(f'Maximum null-pair logit gap: {np.max(np.abs(null_pairs.forward-null_pairs.reverse)):.2g}')\n",
-    "display(pd.DataFrame(saved_json('temporal_diagnostics/null_reproduction.json')))\n",
-    "control_summary = csv('temporal_diagnostics/direction_controls_summary.csv')\n",
-    "display(control_summary.query(\"scheme == 'source_folds' and metric == 'pair_accuracy' and method in ['layer16_pooled', 'layer16_temporal']\")\n",
-    "    .pivot(index='condition', columns='method', values='mean').mul(100).round(1))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b382f7c3",
-   "metadata": {},
-   "source": [
-    "> **Original reference run:** numerical commentary below describes the earlier local run. Generated tables/plots show this Colab run; compare them in section D.\n",
-    "\n",
-    "We also reversed the eight feature bins, or replaced every bin by the temporal mean, while keeping the saved temporal direction-head weights. These are interventions on features, not rendered videos. Temporal pooling can retain contextual order information; averaging bins does not necessarily delete every order cue encoded in each feature.\n",
-    "\n",
-    "For source holdout, the temporal-bin head scored 56% on intact inputs, 48% after bin reversal, and 67% after repeating the temporal mean. These exploratory results do not support the simple assumption that preserving explicit feature-bin order must improve this small-sample readout.\n",
-    "\n",
-    "### How does the existing order probe respond?\n",
-    "\n",
-    "The earlier UCF order probe receives these new inputs without retraining. Below are its mean scores, averaged across both directions and then sources. Its training anchors are 0 for full shuffle and 1 for intact, not perceptual endpoints. The baseline and joint curves use their own training anchors."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "14dba442",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-09-27T13:37:59.756140Z",
-     "iopub.status.busy": "2026-09-27T13:37:59.756140Z",
-     "iopub.status.idle": "2026-09-27T13:37:59.773614Z",
-     "shell.execute_reply": "2026-09-27T13:37:59.773053Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "coherence = csv('temporal_diagnostics/coherence_control_summary.csv')\n",
-    "display(coherence.query(\"scheme == 'source_folds' and method == 'layer16' and metric in ['score', 'delta_from_intact']\")\n",
-    "    .pivot(index='condition', columns='metric', values='mean').round(3))\n",
-    "display(Image(filename=str(BASE / 'temporal_diagnostics/temporal_controls.png'), width=1050))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a502738a",
-   "metadata": {},
-   "source": [
-    "> **Original reference run:** numerical commentary below describes the earlier local run. Generated tables/plots show this Colab run; compare them in section D.\n",
-    "\n",
-    "**Comment:** Interpret these scores as responses of a learned manipulation readout. Local reversals and shifts change more than one temporal property. Static and palindrome conditions have no assigned coherence label. The order head was explicitly trained for reversal consistency, whereas the direction head was trained to separate reversals; both can read different combinations of the same layer's features.\n",
-    "\n",
-    "The pooled direction head's forward-member preference drops from 73% intact to 61%, 48% and 35% under local reversal in blocks of 2, 8 and 16. Circular shifts retain 68%; full frame shuffling leaves 43%. These are descriptive responses to the manipulations, not correctness judgments about their physical arrow.\n",
-    "\n",
-    "The order head gives a repeated still frame a mean score of **1.076**, compared with **0.999** for intact video; the palindrome scores **0.908** and the circular shift **0.950**. This highlights that a high score does not require a progressing event. It fits the learned smoothness/order target, without validating perceived coherence.\n",
-    "\n",
-    "There are 2,200 diagnostic condition records and 1,000 new unique encoder inputs. The sample size for generalization is still 100 source groups. New transformations do not create new independent source videos."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b93cce2a",
-   "metadata": {},
-   "source": [
-    "> **Original reference run:** numerical commentary below describes the earlier local run. Generated tables/plots show this Colab run; compare them in section D.\n",
-    "\n",
-    "## 12. All evidence together\n",
-    "\n",
-    "| Evidence | Observed result | Supported conclusion |\n",
-    "|---|---|---|\n",
-    "| Initial final-layer pilot | Ranking better than threshold transfer; supplied cells were already shuffled | Additional-order sensitivity; corrected initial labels |\n",
-    "| MAT layer sweep | Layer 16 BA 98.21%; 93.75% excluding anomalous version 2 | A useful exploratory layer on four related source variants |\n",
-    "| Untrained reversal tolerance | 4/4 intact reversals accepted | Existing MAT binary probe tolerates these reversed motions |\n",
-    "| New MAT templates | Layer 16 98.98% ranking; pixels 100% | Good manipulation/template decoding; pixel confounding remains |\n",
-    "| Frozen IntPhys2 transfer | Layer 16 readout 34.17%; negative MAE 47.5% | No validated continuity/physics transfer |\n",
-    "| UCF source/action transfer | Layer 16 99.95% ranking; negative MAE 100% | Order disruption generalizes beyond the original stimuli |\n",
-    "| UCF matched levels | Layer 16 78.95%; negative MAE 97.37% | Approximate matching did not remove the pixel cue |\n",
-    "| UCF fixed 0.5 threshold | Layer 16 68.125% balanced accuracy | Pair ranking is not a reliable universal classifier threshold |\n",
-    "| Arrow of time, source holdout | Pooled layer 16 73%, CI 65–81%; permutation p ≈ .0099 | Direction cues accessible within represented actions |\n",
-    "| Arrow of time, action holdout | Pooled layer 16 49%, CI 40–58% | Reliable direction transfer to new actions not established |\n",
-    "| New transformations / nulls | Static order score 1.076 versus intact 0.999; null direction pairs 50% | High order score need not imply a progressing event |\n",
-    "\n",
-    "### What can we say about layer 16?\n",
-    "\n",
-    "**It contains information useful for reading out temporal order and some action-dependent playback direction. The present evidence does not establish a dedicated or general temporal-coherence feature.** The pixel ceiling, negative physical transfer, weak threshold transfer, and action-holdout direction failure all constrain the claim.\n",
-    "\n",
-    "The next substantive improvement would be independent sources with clearly interpretable temporal violations and stronger control of residual pixel/motion cues. A held-out set of physically irreversible events would test direction more cleanly. Human coherence validation remains deferred, as requested. We have not collected or imputed those ratings.\n",
-    "\n",
-    "### Shared limitations\n",
-    "\n",
-    "- Layer 16 was selected after exploratory results; it is fixed in the later studies but not an independently selected universal best layer.\n",
-    "- MAT augmentation repeatedly uses four related source variants. UCF follow-ups repeatedly use the same 100 sources and ten actions. Encoder pretraining overlap is unknown.\n",
-    "- Video domains, sampling spans and frame counts differ across studies. No negative transfer result isolates one cause.\n",
-    "- Bootstrap intervals condition on fitted folds and sampled actions. Exploratory comparisons are not corrected confirmatory tests.\n",
-    "- No readout was calibrated to human experience, and a probe weight is not a causal localization of a feature."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "fea732c5",
-   "metadata": {},
-   "source": [
-    "> **Original reference run:** numerical commentary below describes the earlier local run. Generated tables/plots show this Colab run; compare them in section D.\n",
-    "\n",
-    "### Retained checks and supplementary pilot controls\n",
-    "\n",
-    "Checkpoint hashes, sequence indices, source-group splits, feature reproduction checks and readout weights are saved alongside the tables. The current extraction reproduced both pooled and temporal reference activations exactly. Static/palindrome prediction identity is checked above.\n",
-    "\n",
-    "The historical pilot also tried contextual-feature roughness and tested its fitted classifiers on other shuffle types and reversal. These results are retained below for completeness. A naive “rougher latent trajectory = less coherent” rule was not reliable: only about 21.9% of full shuffles increased that roughness. A contextualized token trajectory cannot be assumed to behave like raw pixel motion."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "93048822",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-09-27T13:37:59.794801Z",
-     "iopub.status.busy": "2026-09-27T13:37:59.794801Z",
-     "iopub.status.idle": "2026-09-27T13:37:59.817297Z",
-     "shell.execute_reply": "2026-09-27T13:37:59.817297Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "pilot_pairs = pd.read_csv(PILOT / 'paired_scores.csv')\n",
-    "display(pilot_pairs.groupby(['condition', 'score']).fraction_shuffles_above_original.mean().round(3))\n",
-    "transfer = pd.read_csv(PILOT / 'direction_and_block_transfer.csv')\n",
-    "display(transfer.query(\"method == 'V-JEPA 2 pooled features'\").groupby(['trained_on', 'evaluated_condition'])\n",
-    "    .fraction_called_shuffled.mean().unstack().round(3))\n",
-    "display(pd.DataFrame(saved_json('temporal_diagnostics/feature_reproduction.json')))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "020a0ba2",
-   "metadata": {},
-   "source": [
-    "## D. Did the rebuilt results agree?\n",
-    "\n",
-    "This table is calculated from the new predictions. It compares the main outcomes with the original local reference. Identical random seeds and source revisions do not guarantee bitwise identity across GPU kernels or linear algebra libraries; numerical differences are reported rather than hidden. A changed scientific conclusion requires examination, even if all code cells ran."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "15dcdfe8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def value(frame, query, column='mean'):\n",
-    "    rows = frame.query(query)\n",
-    "    assert len(rows) == 1, (query, len(rows))\n",
-    "    return float(rows.iloc[0][column])\n",
-    "new = [\n",
-    "    ('MAT layer 16 balanced accuracy', .9821428571428572,\n",
-    "     value(layers, \"layer == 16 and method == 'token_norm' and exclude_2frame == False\", 'balanced_accuracy')),\n",
-    "    ('IntPhys2 possible > impossible', 41/120,\n",
-    "     value(main_physical, \"method == 'graded_ensemble'\", 'matched_pair_accuracy')),\n",
-    "    ('UCF core level ranking', .9995, float(recomputed['layer16'])),\n",
-    "    ('UCF pixel-MAE level ranking', 1., float(recomputed['negative_pixel_mae'])),\n",
-    "    ('UCF fixed-threshold balanced accuracy', .68125, float(balanced_accuracy)),\n",
-    "    ('Direction: source holdout', .73,\n",
-    "     value(csv('temporal_diagnostics/aot_summary.csv'), \"scheme == 'source_folds' and method == 'layer16_pooled' and metric == 'pair_accuracy'\")),\n",
-    "    ('Direction: action holdout', .49,\n",
-    "     value(csv('temporal_diagnostics/aot_summary.csv'), \"scheme == 'action_holdout' and method == 'layer16_pooled' and metric == 'pair_accuracy'\"))]\n",
-    "comparison = pd.DataFrame(new, columns=['Measure', 'Original reference', 'Regenerated'])\n",
-    "comparison['Difference (percentage points)'] = 100*(comparison.Regenerated-comparison['Original reference'])\n",
-    "display(comparison.round(6))\n",
-    "comparison.to_csv(BASE/'colab_reference_comparison.csv', index=False)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "1d273969",
-   "metadata": {},
-   "source": [
-    "### Completion record and downloadable results\n",
-    "\n",
-    "This final cell requires all seven stages, checks the raw reconstruction and null controls, saves package versions, and creates a results archive. The archive contains features, fitted weights, predictions, figures, protocols and logs. The large raw video/model downloads remain separate and reproducibly downloadable. Save the executed notebook using Colab's **File → Download → Download .ipynb**; download the results ZIP from Colab's Files panel if wanted.\n",
-    "\n",
-    "Public sources: [runtime and lossless MAT inputs](https://huggingface.co/datasets/Iuda/vjepa-temporal-coherence), [V-JEPA 2 checkpoint](https://huggingface.co/facebook/vjepa2-vitl-fpc64-256), [UCF101 subset](https://huggingface.co/datasets/sayakpaul/ucf101-subset), and [IntPhys2](https://huggingface.co/datasets/facebook/IntPhys2). Source revisions are pinned above. The local-reference discussion draws on [Shuffle and Learn](https://arxiv.org/abs/1603.08561) and [Learning and Using the Arrow of Time](https://openaccess.thecvf.com/content_cvpr_2018/papers/Wei_Learning_and_Using_CVPR_2018_paper.pdf)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "4ae5375a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import importlib.metadata as package_metadata\n",
-    "receipts = [json.loads((ROOT/f'logs/{s}_complete.json').read_text()) for s in pipeline.STAGES]\n",
-    "raw_checks = saved_json('raw_input_verification.json')\n",
-    "assert len(raw_checks) == 32 and all(r['raw_pixels_verified'] for r in raw_checks)\n",
-    "assert np.allclose(null_pairs.forward, null_pairs.reverse, atol=1e-10, rtol=0)\n",
-    "validation = {'complete': True, 'raw_cells_verified': len(raw_checks), 'stages': receipts,\n",
-    "    'cold_start': json.loads((ROOT/'logs/cold_start.json').read_text()),\n",
-    "    'elapsed_seconds': round(time.time()-STARTED, 2), 'python': sys.version,\n",
-    "    'versions': {p: package_metadata.version(p) for p in ['torch','transformers','numpy','scipy','pandas','scikit-learn','pillow','opencv-python-headless']},\n",
-    "    'bundle_revision': BUNDLE_REVISION, 'human_ratings_collected': False,\n",
-    "    'reference_comparison': comparison.to_dict('records')}\n",
-    "(BASE/'colab_validation.json').write_text(json.dumps(validation, indent=2))\n",
-    "archive_path = ROOT/'colab_results.zip'\n",
-    "with zipfile.ZipFile(archive_path, 'w', zipfile.ZIP_DEFLATED) as archive:\n",
-    "    for folder in [ROOT/'outputs', ROOT/'logs']:\n",
-    "        for path in folder.rglob('*'):\n",
-    "            if path.is_file(): archive.write(path, path.relative_to(ROOT))\n",
-    "print('ALL STAGES COMPLETE. Results:', archive_path)\n",
-    "display(pd.DataFrame(receipts)[['stage','elapsed_seconds','completed_utc']])"
+    "**Readout:** Performance above chance supports accessible information for that dataset's labels. Pixel baselines constrain the interpretation. MAT has only four related sources; physical plausibility, playback direction and perceived coherence remain distinct."
    ]
   }
  ],
@@ -1259,12 +329,11 @@
    "name": "python"
   },
   "temporal_coherence": {
-   "anonymous_inputs": true,
+   "classifier_training": true,
+   "cross_dataset_transfer": false,
    "encoder_frozen": true,
-   "human_ratings_collected": false,
-   "layer": 16,
-   "raw_regeneration": true,
-   "seed": 20260927
+   "evaluation": "grouped within-dataset folds",
+   "layer": 16
   }
  },
  "nbformat": 4,

verification.json

@@ -1,80 +1,92 @@
 {
-  "test_date_utc": "2026-09-27",
+  "verified_utc": "2026-09-29T15:29:43.438497+00:00",
   "gpu": "NVIDIA L4",
   "execution_passed": true,
-  "execution_evidence": "Saved nbclient execution log",
-  "cold_start": {
-    "started_utc": "2026-09-27T14:15:41Z",
-    "preexisting_feature_files": 0,
-    "preexisting_prediction_files": 0,
-    "cold_start": true,
-    "anonymous_downloads": true,
-    "bundle_revision": "85b6a55f474a04a36a3149c45a6d9a3598f7c981",
-    "gpu": "NVIDIA L4"
-  },
-  "raw_stages_completed": [
-    "mat",
-    "pilot",
-    "layers",
-    "graded",
-    "physical",
-    "broad",
-    "direction"
-  ],
-  "raw_stage_elapsed_seconds": 2225.4,
-  "validation_sequence": [
-    "All seven experimental stages regenerated from raw inputs with zero preexisting features or predictions.",
-    "The report then encountered a missing design_integrity.json dependency; the report was changed to derive it from the regenerated manifest.",
-    "A clean kernel executed all 34 corrected notebook code cells successfully, reusing the features generated in the raw run."
-  ],
-  "full_notebook_execution": {
-    "output": "/content/temporal_coherence_colab_executed.ipynb",
-    "elapsed_seconds": 560.9585506916046,
+  "execution": {
+    "elapsed_seconds": 942.6834290027618,
     "errors": [],
-    "executed_code_cells": 34,
-    "notebook_sha256": "94f1a146b9a8fb4517588087ae9842ec6725e8e270b4b900b164ea560557a90e"
+    "executed_code_cells": 7,
+    "source_sha256": "5ad5ef99c2b96a6eba2c238cc42e6454bc62c36b7974dd44b0f946280d860f0c",
+    "executed_sha256": "518e3825593287bc1f1edf197716197e4d3712f877de194be95d51a80b3f52f6"
+  },
+  "analysis": "Independent classifiers fitted and evaluated within each dataset",
+  "cross_dataset_classifier_transfer": false,
+  "encoder_frozen": true,
+  "input_counts": {
+    "IntPhys": 240,
+    "MAT": 56,
+    "UCF": 1000
+  },
+  "source_counts": {
+    "IntPhys": 60,
+    "MAT": 4,
+    "UCF": 100
   },
-  "delivered_source_sha256": "4d5bcf29307f84ad57d2acdfe762f2fef88d175ddd8f3d557c27ab9408a2a271",
-  "executed_artifacts_retrieved": false,
-  "artifact_note": "The runtime expired before the final executed notebook and results ZIP were downloaded. Saved logs and retrieved metric CSVs are retained. The delivered notebook has cleared outputs.",
-  "arrow_of_time_pooled_pair_accuracy": [
+  "results": [
     {
-      "scheme": "action_holdout",
-      "method": "layer16_pooled",
-      "condition": "intact",
-      "metric": "pair_accuracy",
-      "n_sources": "100",
-      "mean": "0.51",
-      "ci95_low": "0.42",
-      "ci95_high": "0.6"
+      "task": "MAT order",
+      "method": "Layer 16",
+      "sources": 4,
+      "balanced_accuracy": 1.0,
+      "auc": 1.0,
+      "within_source_ranking": 1.0
     },
     {
-      "scheme": "source_folds",
-      "method": "layer16_pooled",
-      "condition": "intact",
-      "metric": "pair_accuracy",
-      "n_sources": "100",
-      "mean": "0.72",
-      "ci95_low": "0.64",
-      "ci95_high": "0.8"
+      "task": "MAT order",
+      "method": "Pixels",
+      "sources": 4,
+      "balanced_accuracy": 0.8333333333333333,
+      "auc": 0.875,
+      "within_source_ranking": 1.0
+    },
+    {
+      "task": "UCF order",
+      "method": "Layer 16",
+      "sources": 100,
+      "balanced_accuracy": 0.945625,
+      "auc": 0.9907625,
+      "within_source_ranking": 0.999375
+    },
+    {
+      "task": "UCF order",
+      "method": "Pixels",
+      "sources": 100,
+      "balanced_accuracy": 0.635,
+      "auc": 0.6855,
+      "within_source_ranking": 1.0
+    },
+    {
+      "task": "UCF direction",
+      "method": "Layer 16",
+      "sources": 100,
+      "balanced_accuracy": 0.5549999999999999,
+      "auc": 0.5705,
+      "within_source_ranking": 0.7
+    },
+    {
+      "task": "UCF direction",
+      "method": "Pixels",
+      "sources": 100,
+      "balanced_accuracy": 0.53,
+      "auc": 0.5762999999999999,
+      "within_source_ranking": 0.53
+    },
+    {
+      "task": "IntPhys continuity",
+      "method": "Layer 16",
+      "sources": 60,
+      "balanced_accuracy": 0.5874999999999999,
+      "auc": 0.6088194444444445,
+      "within_source_ranking": 0.7916666666666666
+    },
+    {
+      "task": "IntPhys continuity",
+      "method": "Pixels",
+      "sources": 60,
+      "balanced_accuracy": 0.5,
+      "auc": 0.5002777777777778,
+      "within_source_ranking": 0.5166666666666667
     }
   ],
-  "cross_platform_checks": {
-    "representative_clip": "drag_08",
-    "same_model_sha256": true,
-    "MAT_preprocessed_hashes_match_original": 32,
-    "layer16_pooled_max_abs_difference": 0.0008276179432868958,
-    "layer16_temporal_max_abs_difference": 0.017317771911621094,
-    "note": "Cross-platform activations are not bitwise identical. Regenerated metrics are compared separately; same-runtime feature reproduction uses the original tolerances."
-  },
-  "evidence_sha256": {
-    "colab_aot_summary.csv": "650236420e070b59ff7520805877c7c257841d22f4ac05ac20478aae24c337a6",
-    "colab_broad_summary.csv": "833da463aa24c11b05fbedff77b5d41fe67546c3f74d561f831227f2efdb28a9",
-    "colab_graded_summary.csv": "c82fc6319e0cf875a9e5f7608d5a013dc2d9b550825df8e472dc198e0f7a459d",
-    "colab_layer_summary.csv": "725cfe5d6fcf4502fe47622ef2c840a39634c97ad9ea00e94ad0e36cf1efb486",
-    "colab_physical_summary.csv": "a7e372918a249e0e4152b1b6e0c8cc827711b6292067904c569eb893e31dbb29",
-    "rebuild_run_2.log": "85c43686650bdd882123f0975f1d1afe74d456c0cf8c63dc93d1c9f01e9573f4",
-    "rebuild_run_3.log": "5f3d3aff4d5ed57f195e7b020b6b54997e4cc253f43b1e88a8184a2293bcfab0"
-  },
-  "colab_url": "https://colab.research.google.com/gist/UYildiz12/fa02787a1a0d611b613219cdd53fa859/temporal_coherence_colab.ipynb"
+  "results_zip_sha256": "f34b2a653022eb1204d4c06e3554a7764958fb9b845bf90e52d018fd33f3aa06"
 }

within_dataset_results.csv

@@ -0,0 +1,9 @@
+task,method,sources,balanced_accuracy,auc,within_source_ranking
+MAT order,Layer 16,4,1.0,1.0,1.0
+MAT order,Pixels,4,0.8333333333333333,0.875,1.0
+UCF order,Layer 16,100,0.945625,0.9907625,0.999375
+UCF order,Pixels,100,0.635,0.6855,1.0
+UCF direction,Layer 16,100,0.5549999999999999,0.5705,0.7
+UCF direction,Pixels,100,0.53,0.5762999999999999,0.53
+IntPhys continuity,Layer 16,60,0.5874999999999999,0.6088194444444445,0.7916666666666666
+IntPhys continuity,Pixels,60,0.5,0.5002777777777778,0.5166666666666667