samueleruf/physloc-review_L0_f37

PhysLoc

Physics-violation video clips with spatio-temporal annotations: every invalid clip ships where the violation is, when it happens, and how badly -- all derived from the simulator rather than annotated by hand.

Clips come in twins. A valid clip and its invalid partner share a scene, a seed, and a bit-identical prefix up to t_event; only after that do they differ. That is what makes the difference between them attributable to the intervention and nothing else.

What is here

clips	163 (150 invalid, 13 valid)
pairs	13
scenarios	12
violation families	23
tier	debug+f37
moving camera	0 clips (0%)
complexity	L0 163
with distractors	0 clips (0%)
condition	standard 163

The complexity ladder

SCENE REALISM, four levels, each the one below plus one thing. Every clip carries its level in complexity, so a level is a filter rather than a separate download, and each level draws its OWN scenes -- an L1 clip is not an L0 clip in better materials.

level	adds	background	objects	materials	share	built
L0	the baseline	solid	primitive	one shared density	50%	yes
L1	materials — wood, steel, rubber	solid	primitive	yes	25%	yes
L2	an HDRI environment	hdri	primitive	yes	15%	yes
L3	GSO objects — real 3D scans	hdri	gso	yes	10%	yes

Difficulty conditions

Not levels -- every clip carries exactly ONE of these, applied inside every level, so "what does clutter cost" is answerable at each realism level and not only at the top. Filter on condition.

condition	share	camera	extra objects	objects with invalid physics
standard	60%	static	—	1
camera	10%	moves	—	1
distractors	10%	static	3–10	1
multi	10%	static	3–10	2 … N−1
camera+multi	10%	moves	3–10	2 … N−1

One condition per clip rather than independent coin flips per axis, so every count is exact and every comparison against standard isolates one change. Under multi the scene holds N objects of which M violate, both drawn per clip -- n_actors and n_violators say how many -- so the clip asks WHICH objects are wrong rather than whether something is.

The taxonomy

Five levels: medium -> domain -> family -> scenario -> instance. A cell is one (scenario, family) pair.

domain	the question it asks	n	cells	families
identity	does the object persist and stay itself?	5	48	dissolve, fission, fusion, immutability, permanence
kinematics	is unsupported motion consistent with g?	5	34	antigravity, continuity, newton1_inertia, non_parabolic, time_slip
contact	do bodies interact legally when they touch?	2	15	solidity, superelastic
dynamics	do forces and masses behave?	3	19	angular_momentum, newton2_mass, phantom_impulse
equilibrium	do resting and supported bodies behave?	2	16	friction, support
optical	is light consistent with geometry?	3	3	shadow, shadow_inverted, shadow_shape
appearance	does the object look like itself from frame to frame?	2	26	colour_shift, deformation
global	are the scene's constants physical?	1	5	global_gravity

scenario	medium	families	what happens
barrier_pass	rigid	14	ball rolls into a solid wall and bounces back
collision	rigid	16	two spheres roll toward each other
drop	rigid	14	sphere or cube falls to a floor and bounces
occluder_pass	rigid	12	body travels behind a screen and re-emerges
pendulum_swing	rigid	8	bob on a rigid rod, swung from a pivot (scripted, not solved)
pour	granular	17	a loose column of grains falls into an open box (96 at the debug tier, 212 above)
pyramid_impact	rigid	13	cube dropped onto a sphere pyramid
ramp_slide	rigid	11	block slides down an incline
resting_table	rigid	11	several bodies at rest on a surface
rolling_ramp	rigid	16	cube tumbles down a raised ramp and off its lip
shadow_track	optical	10	object translates under a fixed light
stack_topple	rigid	13	stacked bodies, marginally stable
toss	rigid	11	body thrown on a ballistic arc

Dataset statistics

Computed from every clip's metadata.json; the numbers behind each figure are in stats/stats.json.

What the release is made of: complexity levels, difficulty conditions against their declared shares, severity bins, and violator timing.

Which physics is violated -- domain (inner ring) and family (outer ring) -- and how many clips each scenario contributes.

The scenario x family lattice: violated clips per cell, families grouped under their domain, with row and column totals.

Detection difficulty: the label split, the split per complexity level, which factor set each label, and the rule table labels are computed from.

Every difficulty factor as a histogram of the release, against the two cuts that make its easy, moderate and hard zones.

When violations fire, how long until they are visible, and how strong they measure at each severity bin.

Files

• clips/<release>/<level>/<scenario>/<seed>_<condition>/<clip>/ -- one folder per clip, valid or invalid_<family>_<bin>: video.mp4, metadata.json, segmentations.npz, instances.npz, traj.npz, bodies.npz, energy.npz, and on invalid clips masks.npz and objects.npz. This is the data, in the same layout the generator writes.
• The raw geometry passes (depth, optical flow, normals, object coordinates) are not in this release. They are about 86% of the bytes and are packaged only on request.
• loader.py -- reads this folder (numpy only; imageio or OpenCV for the video).
• index.parquet -- one row per clip: uids, scenario, family, severity, windows, camera motion, actor shape and material.
• splits/*.txt -- clip uids per split.

Splits leak nothing

Splits are grouped by pair_uid, never by clip. A valid twin and its invalid siblings share every frame before t_event, so splitting them apart would put the answer on the other side.

Pairs are ordered by a hash of their uid and cut at the quantiles WITHIN each scenario, so every split sees every scenario and the proportions are exact. There is no rng, so reproducing this release reproduces its splits. Adding clips moves the boundaries.

Every split ships every annotation. The split is a label, not a filter: you can re-cut it, and you can score any clip in the release. If you need a genuinely blind held-out set -- for a leaderboard others submit to -- strip the annotations from splits/held_out.txt at that point; nothing here has to be regenerated to do it.

Downloading

hf download <this repo> --repo-type dataset --local-dir physloc
# only what a video model needs:
hf download <this repo> --repo-type dataset --local-dir physloc \
    --include "*.py" --include "*.txt" --include "*/metadata.json" --include "*/video.mp4"

Reading it

loader.py ships in this folder and is the one reader: import it from here in any project, or copy it. It derives every annotation below from the stored files. fields picks what an item carries, filters pick the clips, and unit="pair" gives one item per scene -- its valid clip and every invalid clip made from it.

import sys; sys.path.insert(0, "physloc")   # the downloaded folder
from loader import PhysLocDataset, FIELDS, collate

ds = PhysLocDataset("physloc", label="invalid", split="debug",
                    fields=("video", "violation_mask", "severity_map"))
item = ds[0]
item["video"]           # uint8 [T,H,W,3]
item["violation_mask"]  # bool [T,H,W]   the localisation target
item["severity_map"]    # float32 [T,H,W]

scenes = PhysLocDataset("physloc", unit="pair", fields=("video_path",))
scenes[0]["valid"], scenes[0]["invalid"]   # one scene, both sides

clip = ds.clips[0]       # or everything, lazily, from one clip
clip.objects["severity"] # [K,T], one row per violating object

sorted(FIELDS) lists every field. Each clip folder also opens without the loader: video.mp4 plays in any player.

The annotations, and what they are not

Stored (invalid clips only; schema version 2):

• masks.npz violation -- uint16 [T,H,W], 0 or the violating object's instance id, unioned over BOTH twins: a vanished body has no pixels in the invalid render, which is exactly why the union is needed.
• masks.npz causal / causal_source -- level 1 a violator, level 2 a body it affected, and which violator each pixel belongs to.
• objects.npz -- per violating object, per frame: severity, the clocks active / intervening / consequence / observable / occluded, and the raw residual and its 0..1 score.

Derived by the loader: violation_mask (violation > 0), visible_violation (the part visible in the invalid video), severity_map (each object's severity painted on its pixels), reference_mask (where the violators lawfully are), clip timelines and latent token grids. divergence (|valid - invalid|) is for inspection, never training: it diverges everywhere downstream of the event, so a model trained on it learns to find the edit rather than the physics.

Scenarios

• barrier_pass (15 clips)
• collision (17 clips)
• drop (15 clips)
• occluder_pass (13 clips)
• pendulum_swing (9 clips)
• pour (18 clips)
• pyramid_impact (14 clips)
• ramp_slide (12 clips)
• resting_table (12 clips)
• shadow_track (11 clips)
• stack_topple (14 clips)
• toss (13 clips)

Violation families

• angular_momentum (3 clips)
• antigravity (5 clips)
• colour_shift (12 clips)
• continuity (12 clips)
• deformation (12 clips)
• dissolve (12 clips)
• fission (6 clips)
• friction (5 clips)
• fusion (2 clips)
• global_gravity (5 clips)
• immutability (12 clips)
• newton1_inertia (5 clips)
• newton2_mass (2 clips)
• non_parabolic (5 clips)
• permanence (12 clips)
• phantom_impulse (12 clips)
• shadow (1 clips)
• shadow_inverted (1 clips)
• shadow_shape (1 clips)
• solidity (8 clips)
• superelastic (6 clips)
• support (9 clips)
• time_slip (2 clips)