Upload folder using huggingface_hub

clevrer_lite/__init__.py

@@ -0,0 +1,8 @@
+"""CLEVRER-lite: a small CLEVRER-like video-reasoning environment with a gym API."""
+
+from .env import CLEVRERLiteEnv
+from . import config, physics, renderer, simulate, events, questions
+
+__all__ = ["CLEVRERLiteEnv", "config", "physics", "renderer", "simulate",
+           "events", "questions"]
+__version__ = "0.1.0"

clevrer_lite/config.py

@@ -0,0 +1,50 @@
+"""Global configuration: CLEVRER-style attributes, palette and physics constants."""
+
+# ---------------------------------------------------------------- attributes
+# The 8 CLEVRER colors (RGB, roughly matched to CLEVRER's palette).
+COLORS = {
+    "gray":   (144, 144, 148),
+    "red":    (196,  44,  38),
+    "blue":   ( 46,  71, 190),
+    "green":  ( 62, 131,  55),
+    "brown":  ( 96,  58,  33),
+    "purple": (110,  46, 150),
+    "cyan":   ( 63, 156, 158),
+    "yellow": (196, 150,  18),
+}
+COLOR_NAMES = list(COLORS.keys())
+
+SHAPES = ["cube", "sphere", "cylinder"]
+MATERIALS = ["rubber", "metal"]
+SIZES = ["small", "large"]
+
+# physical radius range for each size class (world units)
+SIZE_RADIUS = {"small": (0.14, 0.20), "large": (0.26, 0.34)}
+
+# ---------------------------------------------------------------- world
+WORLD_HALF = 2.0      # arena is [-WORLD_HALF, WORLD_HALF]^2 (top-down view)
+SPAWN_HALF = 1.55     # objects spawn inside [-SPAWN_HALF, SPAWN_HALF]^2
+
+# ---------------------------------------------------------------- physics
+FRAME_DT = 1.0 / 25.0            # one rendered frame = 40 ms (25 fps)
+SUBSTEPS = 5                     # physics substeps per rendered frame
+SUB_DT = FRAME_DT / SUBSTEPS     # physics integration step
+
+SPEED_RANGE = (0.7, 1.7)         # initial speed range for moving objects
+RESTITUTION = 0.95               # object-object bounciness
+WALL_RESTITUTION = 0.90          # object-wall bounciness
+DRAG = 0.9992                    # velocity decay per substep (tiny air drag)
+
+DENSITY = {"rubber": 1.0, "metal": 2.5}
+
+MOVE_THRESH = 0.12               # |v| above this counts as "moving"
+MIN_RUN_FRAMES = 4               # a motion segment must last this many frames
+MIN_EVENT_GAP_FRAMES = 6         # same-pair contacts within this window = 1 event
+CAUSE_WINDOW_FRAMES = 4          # collision this close to a start-of-motion explains it
+
+# ---------------------------------------------------------------- probe (gym agent)
+PROBE_COLOR = "gray"
+PROBE_SIZE = "medium"
+PROBE_RADIUS = 0.22
+PROBE_IMPULSE = 1.1              # delta-v applied to the probe ball per action
+ACTION_LABELS = ["noop", "push_east", "push_north", "push_west", "push_south"]

clevrer_lite/env.py

@@ -0,0 +1,164 @@
+"""OpenAI Gym wrapper for the CLEVRER-lite environment.
+
+    env = CLEVRERLiteEnv()
+    obs, info = env.reset(seed=0)
+    obs, reward, terminated, truncated, info = env.step(env.action_space.sample())
+
+Observation: (frame_size, frame_size, 3) uint8 RGB frame (top-down view).
+Action:      Discrete(5) - {noop, push probe ball E/N/W/S}.
+             With ``probe=False`` every action is a no-op, giving the purely
+             passive CLEVRER dynamics.
+Reward:      0.0 (the task is video reasoning, not control).
+Info:        per-frame physics state + collisions so far.
+
+The env records the full trajectory, so after an episode you can call
+``extract_events()`` / ``build_questions()`` to get CLEVRER-style annotations.
+"""
+
+import numpy as np
+
+try:
+    import gym
+except ImportError:                                    # pragma: no cover
+    import gymnasium as gym
+from gym import spaces
+
+from . import config, renderer, simulate, events as events_mod, questions as questions_mod
+
+
+class CLEVRERLiteEnv(gym.Env):
+    """A CLEVRER-like world of colliding objects as a gym environment."""
+
+    metadata = {
+        "render_modes": ["rgb_array"],
+        "render_fps": int(round(1.0 / config.FRAME_DT)),
+    }
+
+    def __init__(self, num_objects=(3, 6), num_frames=64, frame_size=128,
+                 probe=False, min_collisions=2, min_initially_moving=2,
+                 render_mode=None):
+        self.num_objects = (tuple(num_objects) if isinstance(num_objects, (tuple, list))
+                            else (int(num_objects), int(num_objects)))
+        self.num_frames = int(num_frames)
+        self.frame_size = int(frame_size)
+        self.probe = bool(probe)
+        self.min_collisions = int(min_collisions)
+        self.min_initially_moving = int(min_initially_moving)
+        self.render_mode = render_mode
+
+        self.observation_space = spaces.Box(0, 255, (self.frame_size, self.frame_size, 3),
+                                            np.uint8)
+        self.action_space = spaces.Discrete(len(config.ACTION_LABELS))
+
+        # episode state
+        self._spec = None
+        self._bodies = None
+        self._t = 0
+        self._last_obs = None
+        self._trajectory = None
+        self._collisions = []
+        self._wall_hits = []
+
+    # ------------------------------------------------------------------ api
+    def reset(self, *, seed=None, options=None):
+        super().reset(seed=seed)
+        rng = self.np_random
+
+        # sample a scene that is rich enough for causal questions
+        for _ in range(60):
+            spec = simulate.sample_spec(rng, rng.integers(self.num_objects[0],
+                                                          self.num_objects[1] + 1),
+                                        probe=self.probe)
+            bodies = simulate.bodies_from_spec(spec)
+            out = simulate.rollout(bodies, self.num_frames)
+            ev = events_mod.extract_events(out["states"], out["collisions"],
+                                           out["wall_hits"], n=len(bodies))
+            stationary = [i for i in range(len(bodies))
+                          if i not in ev["initially_moving"]]
+            if (len(ev["collisions"]) >= self.min_collisions
+                    and len(ev["initially_moving"]) >= self.min_initially_moving
+                    and (not self.probe or len(stationary) >= 1)):
+                break
+        else:
+            pass  # keep the last sample even if not ideal
+
+        self._spec = spec
+        self._bodies = simulate.bodies_from_spec(spec)
+        self._t = 0
+        self._collisions = []
+        self._wall_hits = []
+        self._trajectory = np.zeros((self.num_frames, len(self._bodies), 4))
+        self._last_obs = self._render()
+        return self._last_obs, self._info()
+
+    def step(self, action):
+        if self._bodies is None:
+            raise RuntimeError("call reset() before step()")
+        action = int(action)
+
+        def action_fn(t, bodies):
+            if self.probe and action != 0:
+                dirs = {1: (1, 0), 2: (0, 1), 3: (-1, 0), 4: (0, -1)}
+                dx, dy = dirs[action]
+                for b in bodies:
+                    if b.is_probe:
+                        b.vel = b.vel + np.array([dx, dy]) * (config.PROBE_IMPULSE / b.mass)
+
+        out = simulate.rollout(self._bodies, 1, render_fn=None, action_fn=action_fn)
+        t = self._t
+        self._trajectory[t] = out["states"][0]
+        for c in out["collisions"]:
+            self._collisions.append((t, c[1], c[2]))
+        for (_, i, ax, s) in out["wall_hits"]:
+            self._wall_hits.append((t, i, ax, s))
+
+        self._t += 1
+        self._last_obs = self._render()
+        truncated = bool(self._t >= self.num_frames)
+        info = self._info()
+        info.update({
+            "frame": self._t - 1,
+            "collisions_so_far": len(self._collisions),
+            "latest_collision": self._collisions[-1] if self._collisions else None,
+            "truncated": truncated,
+        })
+        return self._last_obs, 0.0, False, truncated, info
+
+    def render(self):
+        return self._last_obs
+
+    def close(self):
+        self._bodies = None
+
+    # ------------------------------------------------------------ utilities
+    @property
+    def scene(self):
+        """Scene spec (list of dicts) of the current episode."""
+        return self._spec
+
+    @property
+    def trajectory(self):
+        """(T, n, 4) array of (x, y, vx, vy) recorded so far."""
+        return self._trajectory
+
+    def extract_events(self):
+        return events_mod.extract_events(self._trajectory, self._collisions,
+                                         self._wall_hits, n=len(self._bodies))
+
+    def build_questions(self, ev=None, max_questions=8):
+        ev = ev if ev is not None else self.extract_events()
+        return questions_mod.build_questions(self._spec, ev, self.np_random,
+                                             self.num_frames,
+                                             max_questions=max_questions)
+
+    # ------------------------------------------------------------ internals
+    def _render(self):
+        return renderer.render(self._bodies, size=self.frame_size)
+
+    def _info(self):
+        return {
+            "t": self._t,
+            "objects": [b.idx for b in self._bodies],
+            "positions": np.array([b.pos for b in self._bodies]),
+            "speeds": np.array([b.speed for b in self._bodies]),
+        }

clevrer_lite/events.py

@@ -0,0 +1,73 @@
+"""Extract causal events (collisions, starts/stops of motion) from a trajectory.
+
+This is what makes question generation *grounded*: every question/answer is
+derived from events that verifiably happened in the recorded physics rollout.
+"""
+
+import numpy as np
+
+from . import config
+
+
+def extract_events(states, collisions, wall_hits, n):
+    """Args:
+        states: (T, n, 4) per-frame (x, y, vx, vy)
+        collisions: [(t, i, j)] substep-level contact log
+        wall_hits: [(t, i, axis, side)]
+        n: number of objects
+
+    Returns dict with:
+        collisions:  [{frame, objects:[i,j]}] grouped collision events
+        starts:      {obj_idx: [frames]}  times each object starts moving
+        stops:       {obj_idx: [frames]}
+        initially_moving: [obj_idx]
+        moving:      (T, n) bool mask
+        speeds:      (T, n)
+    """
+    T = states.shape[0]
+    speeds = np.linalg.norm(states[:, :, 2:], axis=-1)          # (T, n)
+    moving = speeds > config.MOVE_THRESH
+
+    # ---- group the contact log into collision events ----
+    grouped = []
+    for (t, i, j) in sorted(collisions, key=lambda c: c[0]):
+        if grouped and grouped[-1]["objects"] == [i, j] and \
+                t - grouped[-1]["end"] <= config.MIN_EVENT_GAP_FRAMES:
+            grouped[-1]["end"] = t
+        else:
+            grouped.append({"frame": t, "end": t, "objects": [i, j]})
+    collision_events = [{"frame": g["frame"], "objects": g["objects"]} for g in grouped]
+
+    # ---- start / stop of motion per object ----
+    starts, stops, initially_moving = {}, {}, []
+    min_run = config.MIN_RUN_FRAMES
+    for o in range(n):
+        m = moving[:, o]
+        sts, sps = [], []
+        t = 0
+        while t < T:
+            if m[t]:
+                t2 = t
+                while t2 < T and m[t2]:
+                    t2 += 1
+                if t2 - t >= min_run:
+                    if t == 0:
+                        initially_moving.append(o)
+                    else:
+                        sts.append(t)
+                    sps.append(t2)          # frame where it (first) stops
+                t = t2
+            else:
+                t += 1
+        starts[o] = sts
+        stops[o] = [s for s in sps if s < T - 1]   # ignore end-of-video "stop"
+
+    return {
+        "collisions": collision_events,
+        "starts": starts,
+        "stops": stops,
+        "initially_moving": sorted(initially_moving),
+        "moving": moving,
+        "speeds": speeds,
+        "wall_hits": wall_hits,
+    }

clevrer_lite/generate_dataset.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""Generate a small CLEVRER-lite dataset (GIF videos + JSON annotations).
+
+Examples:
+    python -m clevrer_lite.generate_dataset --num-videos 8 --num-frames 64 --frame-size 128
+    python -m clevrer_lite.generate_dataset --out data/big --num-videos 1000 --num-frames 128
+"""
+
+import argparse
+import json
+import os
+import time
+
+import numpy as np
+from PIL import Image
+
+from . import CLEVRERLiteEnv, config, simulate
+
+
+def describe_events(spec, ev):
+    """Human-readable event descriptions for the annotation file."""
+    objs = {o["idx"]: o for o in spec}
+
+    def ref(i):
+        return "the {} {}".format(objs[i]["color"], objs[i]["shape"])
+
+    collisions = [{
+        "frame": e["frame"],
+        "objects": e["objects"],
+        "description": f"{ref(e['objects'][0])} collided with {ref(e['objects'][1])}",
+    } for e in ev["collisions"]]
+
+    motion = []
+    for o, sts in ev["starts"].items():
+        for s in sts:
+            cause = None
+            for e in ev["collisions"]:
+                a, b = e["objects"]
+                if o in (a, b) and abs(e["frame"] - s) <= config.CAUSE_WINDOW_FRAMES:
+                    cause = e
+                    break
+            motion.append({"object": o, "type": "start", "frame": s,
+                           "cause_collision": cause})
+    return {"collision_events": collisions, "motion_events": motion,
+            "initially_moving": ev["initially_moving"]}
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Generate a CLEVRER-lite dataset")
+    ap.add_argument("--out", default="output")
+    ap.add_argument("--num-videos", type=int, default=8)
+    ap.add_argument("--num-frames", type=int, default=64)
+    ap.add_argument("--frame-size", type=int, default=128)
+    ap.add_argument("--seed", type=int, default=0)
+    ap.add_argument("--gif-fps", type=int, default=12)
+    ap.add_argument("--max-questions", type=int, default=8)
+    args = ap.parse_args()
+
+    video_dir = os.path.join(args.out, "videos")
+    os.makedirs(video_dir, exist_ok=True)
+
+    env = CLEVRERLiteEnv(num_frames=args.num_frames, frame_size=args.frame_size)
+    annotations = []
+    t0 = time.time()
+
+    for v in range(args.num_videos):
+        obs, info = env.reset(seed=args.seed + v)
+        frames = [obs]
+        while True:
+            obs, reward, terminated, truncated, info = env.step(0)   # passive
+            frames.append(obs)
+            if truncated:
+                break
+
+        ev = env.extract_events()
+        qs = env.build_questions(ev, max_questions=args.max_questions)
+        ev_public = {k: v for k, v in ev.items() if k not in ("moving", "speeds")}
+
+        fname = f"video_{v:05d}.gif"
+        imgs = [Image.fromarray(f) for f in frames]
+        imgs[0].save(os.path.join(video_dir, fname), save_all=True,
+                     append_images=imgs[1:], duration=int(1000 / args.gif_fps),
+                     loop=0)
+
+        record = {
+            "video_index": v,
+            "video_filename": f"videos/{fname}",
+            "num_frames": args.num_frames,
+            "frame_size": args.frame_size,
+            "fps": env.metadata["render_fps"],
+            "scene": {"objects": env.scene},
+            "events": describe_events(env.scene, ev),
+            "raw_events": {
+                "collisions": ev_public["collisions"],
+                "starts": {str(k): v for k, v in ev_public["starts"].items()},
+                "stops": {str(k): v for k, v in ev_public["stops"].items()},
+                "initially_moving": ev_public["initially_moving"],
+                "wall_hits": [list(map(int, w)) for w in ev_public["wall_hits"]],
+            },
+            "questions": qs,
+        }
+        annotations.append(record)
+        n_col = len(ev["collisions"])
+        print(f"[{v + 1}/{args.num_videos}] {fname}: "
+              f"{len(env.scene)} objects, {n_col} collisions, {len(qs)} questions")
+
+    with open(os.path.join(args.out, "annotations.json"), "w") as f:
+        json.dump(annotations, f, indent=2)
+
+    dt = time.time() - t0
+    print(f"\nDone: {args.num_videos} videos in {dt:.1f}s "
+          f"({dt / args.num_videos:.2f}s/video) -> {args.out}/")
+    print(f"Total questions: {sum(len(a['questions']) for a in annotations)}")
+
+    # quick distribution summary
+    from collections import Counter
+    types = Counter(q["question_type"] for a in annotations for q in a["questions"])
+    print("Question types:", dict(types))
+    answers = Counter(q["answer"] for a in annotations for q in a["questions"])
+    print("Top answers:", dict(answers.most_common(8)))
+
+
+if __name__ == "__main__":
+    main()

clevrer_lite/physics.py

@@ -0,0 +1,98 @@
+"""Minimal 2D rigid-body physics: discs in a box with elastic collisions.
+
+Cubes and cylinders are *rendered* as squares / rings (top-down view, like
+looking down on the CLEVRER scene) but use a circular footprint for physics.
+This keeps the engine tiny, stable and fast while preserving the causal event
+structure (collisions, starts/stops of motion) that CLEVRER questions need.
+"""
+
+from dataclasses import dataclass, field
+import numpy as np
+
+from . import config
+
+
+@dataclass
+class Body:
+    idx: int
+    color: str
+    shape: str
+    material: str
+    size: str
+    radius: float
+    pos: np.ndarray                       # (2,) world coordinates
+    vel: np.ndarray                       # (2,)
+    spin: float = 0.0                     # visual angular velocity (rad/s)
+    angle: float = 0.0                    # visual rotation angle (rad)
+    mass: float = 1.0
+    is_probe: bool = False
+
+    @property
+    def speed(self) -> float:
+        return float(np.linalg.norm(self.vel))
+
+
+def mass_of(radius: float, material: str) -> float:
+    # all shapes use a circular footprint: m = density * pi * r^2
+    return config.DENSITY[material] * np.pi * radius ** 2
+
+
+class World:
+    """A box arena with elastic object-object and object-wall collisions."""
+
+    def __init__(self, bodies, half: float = config.WORLD_HALF):
+        self.bodies = list(bodies)
+        self.half = half
+
+    def step(self, h: float):
+        """Advance physics by h seconds.
+
+        Returns:
+          contacts: list of (idx_a, idx_b) pairs that collided this step
+          wall_hits: list of (idx, axis, side) with side in {-1, +1}
+        """
+        contacts, wall_hits = [], []
+
+        # integrate
+        for b in self.bodies:
+            b.pos = b.pos + b.vel * h
+            b.vel = b.vel * config.DRAG
+            b.angle = (b.angle + b.spin * h) % (2.0 * np.pi)
+
+        # pairwise object collisions
+        bs = self.bodies
+        for i in range(len(bs)):
+            for j in range(i + 1, len(bs)):
+                A, B = bs[i], bs[j]
+                d = B.pos - A.pos
+                dist = float(np.linalg.norm(d))
+                rsum = A.radius + B.radius
+                if dist < rsum and dist > 1e-9:
+                    n = d / dist
+                    # impulse along the normal if approaching
+                    v_rel_n = float(np.dot(B.vel - A.vel, n))
+                    if v_rel_n < 0.0:
+                        e = config.RESTITUTION
+                        jimp = -(1.0 + e) * v_rel_n / (1.0 / A.mass + 1.0 / B.mass)
+                        A.vel = A.vel - (jimp / A.mass) * n
+                        B.vel = B.vel + (jimp / B.mass) * n
+                        contacts.append((A.idx, B.idx))
+                    # positional correction so objects never sink into each other
+                    push = n * (0.5 * (rsum - dist))
+                    A.pos = A.pos - push
+                    B.pos = B.pos + push
+
+        # walls
+        for b in self.bodies:
+            for ax in range(2):
+                lim = self.half - b.radius
+                if b.pos[ax] > lim and b.vel[ax] > 0:
+                    b.pos[ax] = lim
+                    b.vel[ax] = -b.vel[ax] * config.WALL_RESTITUTION
+                    wall_hits.append((b.idx, ax, +1))
+                elif b.pos[ax] < -lim and b.vel[ax] < 0:
+                    b.pos[ax] = -lim
+                    b.vel[ax] = -b.vel[ax] * config.WALL_RESTITUTION
+                    wall_hits.append((b.idx, ax, -1))
+
+        return contacts, wall_hits

clevrer_lite/questions.py

@@ -0,0 +1,451 @@
+"""CLEVRER-style question generation.
+
+Every question is generated from the *extracted events* of the recorded
+trajectory, so questions and answers are grounded in what actually happened.
+Question types mirror CLEVRER:
+
+  descriptive    - single/multi-step perception on the first frame
+                   ("How many red objects?", "What color is the sphere?")
+  explanatory    - causal/temporal reasoning about collision & motion events
+                   ("What happened right after ... collided?")
+  predictive     - "Will A collide with B by the end of the video?"
+  counterfactual - answered by *re-simulating* the scene with one object
+                   removed, exactly like the real CLEVRER pipeline.
+
+Each question carries: text, answer, multiple-choice list + answer index,
+type, template id, and a simplified functional program.
+"""
+
+import numpy as np
+
+from . import config, simulate
+
+_NOTHING = "nothing happened"
+
+_ATTR_ORDER = ["size", "material", "color", "shape"]
+
+
+# --------------------------------------------------------------------------
+# helpers
+# --------------------------------------------------------------------------
+
+def _ref(obj, objs):
+    """Shortest unambiguous CLEVRER-style reference, e.g. 'the red sphere'."""
+    for attrs in (("color", "shape"), ("color",), ("shape",),
+                  ("size", "color", "shape"), ("material", "color", "shape"),
+                  ("size", "material", "color", "shape")):
+        vals = tuple(obj[a] for a in attrs)
+        if sum(1 for o in objs if tuple(o[a] for a in attrs) == vals) == 1:
+            ordered = [a for a in _ATTR_ORDER if a in attrs]
+            return "the " + " ".join(obj[a] for a in ordered)
+    return f"the object {obj['idx']}"
+
+
+def _shuffle_choices(ans, distractors, rng):
+    """Build a shuffled choice list; returns (choices, answer_index)."""
+    choices = [ans] + [d for d in distractors if d != ans]
+    choices = list(dict.fromkeys(choices))          # dedupe, keep order
+    perm = rng.permutation(len(choices))
+    choices = [choices[i] for i in perm]
+    return choices, int(choices.index(ans))
+
+
+def _numeric_choices(ans, lo, hi, rng, k=6):
+    vals = {ans}
+    pool = [v for v in range(lo, hi + 1) if v != ans]
+    if pool:
+        vals |= set(int(x) for x in rng.choice(pool, size=min(k - 1, len(pool)),
+                                               replace=False))
+    return [str(v) for v in sorted(vals)]
+
+
+def _q(question, answer, choices, answer_index, qtype, template, program):
+    answer = str(answer)
+    if answer_index is None:
+        answer_index = choices.index(answer)
+    return {"question": question, "answer": answer, "choices": choices,
+            "answer_index": answer_index, "question_type": qtype,
+            "template": template, "program": program}
+
+
+def _col_choices(ans, rng):
+    names = list(config.COLOR_NAMES)
+    perm = rng.permutation(len(names))
+    choices = [names[i] for i in perm]
+    return choices, choices.index(ans)
+
+
+# --------------------------------------------------------------------------
+# descriptive questions (about the first frame)
+# --------------------------------------------------------------------------
+
+def _descriptive(objs, ev, rng):
+    out = []
+    n = len(objs)
+    pos0 = {o["idx"]: o["position"] for o in objs}
+
+    out.append(_q("How many objects are there?", str(n),
+                  _numeric_choices(n, 0, max(6, n), rng), None,
+                  "descriptive", "count_all",
+                  [{"op": "count"}]))
+
+    # count by attribute
+    for key, noun in (("color", "objects"), ("shape", "objects"),
+                      ("material", "objects")):
+        values = sorted({o[key] for o in objs})
+        for v in values:
+            cnt = sum(1 for o in objs if o[key] == v)
+            phrase = f"How many {v} {noun} are there?"
+            prog = [{"op": f"filter_{key}", "value": v}, {"op": "count"}]
+            ch = _numeric_choices(cnt, 0, max(6, n), rng)
+            out.append(_q(phrase, str(cnt), ch, None, "descriptive",
+                          f"count_{key}", prog))
+
+    # query color of a unique shape
+    for sh in config.SHAPES:
+        same = [o for o in objs if o["shape"] == sh]
+        if len(same) == 1:
+            o = same[0]
+            ch, ai = _col_choices(o["color"], rng)
+            out.append(_q(f"What color is the {sh}?", o["color"], ch, ai,
+                          "descriptive", "query_color",
+                          [{"op": "filter_shape", "value": sh},
+                           {"op": "query_color"}]))
+
+    # query shape of a unique color
+    for col in config.COLOR_NAMES:
+        same = [o for o in objs if o["color"] == col]
+        if len(same) == 1:
+            o = same[0]
+            ch = list(config.SHAPES)
+            perm = rng.permutation(len(ch))
+            ch = [ch[i] for i in perm]
+            out.append(_q(f"What shape is the {col} object?", o["shape"], ch,
+                          list(ch).index(o["shape"]), "descriptive",
+                          "query_shape",
+                          [{"op": "filter_color", "value": col},
+                           {"op": "query_shape"}]))
+
+    # query material of a unique color+shape
+    for o in objs:
+        same = [x for x in objs if x["color"] == o["color"] and x["shape"] == o["shape"]]
+        if len(same) == 1:
+            ch = list(config.MATERIALS)
+            perm = rng.permutation(len(ch))
+            ch = [ch[i] for i in perm]
+            out.append(_q(f"What material is the {o['color']} {o['shape']} made of?",
+                          o["material"], ch, ch.index(o["material"]),
+                          "descriptive", "query_material",
+                          [{"op": "filter_color", "value": o["color"]},
+                           {"op": "filter_shape", "value": o["shape"]},
+                           {"op": "query_material"}]))
+
+    # spatial relations (margin so 'left of' is unambiguous, exactly one match)
+    margin = 0.6
+    dirs = {
+        "left of":   lambda a, b: (b[0] - a[0]) >= margin,   # a is left of b
+        "right of":  lambda a, b: (a[0] - b[0]) >= margin,
+        "behind":    lambda a, b: (a[1] - b[1]) >= margin,   # +y is far/back
+        "in front of": lambda a, b: (b[1] - a[1]) >= margin,
+    }
+    for rb in objs:
+        for name, fn in dirs.items():
+            cands = [o for o in objs if o["idx"] != rb["idx"] and
+                     fn(pos0[o["idx"]], pos0[rb["idx"]])]
+            if len(cands) == 1:
+                o = cands[0]
+                ch, ai = _col_choices(o["color"], rng)
+                out.append(_q(f"What color is the object {name} {_ref(rb, objs)}?",
+                              o["color"], ch, ai, "descriptive", "query_color_rel",
+                              [{"op": "filter_color", "value": rb["color"]},
+                               {"op": "relate", "direction": name.replace(" ", "_")},
+                               {"op": "query_color"}]))
+    return out
+
+
+# --------------------------------------------------------------------------
+# explanatory questions (causal / temporal)
+# --------------------------------------------------------------------------
+
+def _coll_desc(objs, a, b):
+    return f"{_ref(a, objs)} collided with {_ref(b, objs)}"
+
+
+def _explanatory(objs, ev, rng):
+    out = []
+    cev = ev["collisions"]
+    idx_of = {o["idx"]: o for o in objs}
+    refc = {o["idx"]: _ref(o, objs) for o in objs}
+
+    if not cev:
+        return out
+
+    def ev_desc(e):
+        a, b = e["objects"]
+        return _coll_desc(objs, idx_of[a], idx_of[b])
+
+    # what happened right after / before a collision
+    for k, e in enumerate(cev):
+        for direction, other in (("after", k + 1), ("before", k - 1)):
+            ans = ev_desc(cev[other]) if 0 <= other < len(cev) else _NOTHING
+            distractors = [ev_desc(x) for i, x in enumerate(cev)
+                           if i not in (k, other)]
+            for (t, i, ax, s) in ev["wall_hits"][:40]:
+                d = f"{refc[i]} collided with the wall"
+                if d not in distractors:
+                    distractors.append(d)
+            for o, sts in ev["starts"].items():
+                if o in refc and sts:
+                    d = f"{refc[o]} started moving"
+                    if d not in distractors:
+                        distractors.append(d)
+            if ans != _NOTHING and _NOTHING not in distractors:
+                distractors.append(_NOTHING)
+            if len(distractors) < 3:
+                continue
+            rng.shuffle(distractors)
+            distractors = distractors[:3]
+            a, b = e["objects"]
+            ch, ai = _shuffle_choices(ans, distractors, rng)
+            out.append(_q(f"What happened right {direction} "
+                          f"{ev_desc(e)}?", ans, ch, ai, "explanatory",
+                          f"what_happened_{direction}",
+                          [{"op": "find_collision", "objects": [a, b]},
+                           {"op": f"query_{direction}_event"}]))
+
+    # what caused an object to start moving
+    for o_idx, sts in ev["starts"].items():
+        if o_idx not in idx_of:
+            continue
+        for s in sts:
+            cause = None
+            for e in cev:
+                a, b = e["objects"]
+                if o_idx in (a, b) and abs(e["frame"] - s) <= config.CAUSE_WINDOW_FRAMES:
+                    cause = b if a == o_idx else a
+                    break
+            if cause is None:
+                continue
+            ans = f"the collision with {refc[cause]}"
+            others = [p for e in cev for p in e["objects"]
+                      if p not in (o_idx, cause) and p in refc]
+            distractors = [f"the collision with {refc[p]}" for p in dict.fromkeys(others)]
+            distractors += ["it was pushed by the wall", "nothing - it was already moving"]
+            rng.shuffle(distractors)
+            ch, ai = _shuffle_choices(ans, distractors[:3], rng)
+            out.append(_q(f"What caused {refc[o_idx]} to start moving?", ans, ch, ai,
+                          "explanatory", "cause_of_motion",
+                          [{"op": "filter_object", "idx": o_idx},
+                           {"op": "query_motion_cause"}]))
+
+    # which object started moving right before / after a collision
+    for e in cev:
+        a, b = e["objects"]
+        t = e["frame"]
+        for direction, lo, hi, pick in (("after", t + 1, t + 12, min),
+                                        ("before", max(1, t - 12), t, max)):
+            cands = [(s, o) for o, ss in ev["starts"].items()
+                     if o not in (a, b) and o in idx_of for s in ss
+                     if lo <= s <= hi]
+            if not cands:
+                continue
+            _, ans_o = pick(cands)
+            ans = refc[ans_o]
+            others = [o for o in objs if o["idx"] not in (ans_o, a, b)]
+            distractors = [_ref(o, objs) for o in others]
+            distractors.append("none of them")
+            rng.shuffle(distractors)
+            ch, ai = _shuffle_choices(ans, distractors[:3], rng)
+            out.append(_q(f"Which object started moving right {direction} "
+                          f"{ev_desc(e)}?", ans, ch, ai, "explanatory",
+                          f"who_started_{direction}",
+                          [{"op": "find_collision", "objects": [a, b]},
+                           {"op": f"query_{direction}_motion_start"}]))
+
+    # how many objects were moving when a collision happened
+    for e in cev:
+        a, b = e["objects"]
+        t = min(e["frame"], ev["moving"].shape[0] - 1)
+        cnt = int(ev["moving"][t].sum())
+        ch = _numeric_choices(cnt, 0, len(objs), rng)
+        out.append(_q(f"How many objects were moving when {ev_desc(e)}?",
+                      str(cnt), ch, None, "explanatory", "count_moving_at",
+                      [{"op": "find_collision", "objects": [a, b]},
+                       {"op": "count_moving_at_collision"}]))
+
+    # total number of collisions
+    if len(cev) >= 2:
+        ch = _numeric_choices(len(cev), 0, max(6, len(cev) + 1), rng)
+        out.append(_q("How many collisions happened in the video?",
+                      str(len(cev)), ch, None, "explanatory",
+                      "count_collisions",
+                      [{"op": "filter_event", "type": "collision"}, {"op": "count"}]))
+    return out
+
+
+# --------------------------------------------------------------------------
+# predictive questions (binary, grounded in the full recorded trajectory)
+# --------------------------------------------------------------------------
+
+def _predictive(objs, ev, rng):
+    out = []
+    cev = ev["collisions"]
+    idx_of = {o["idx"]: o for o in objs}
+    pairs_collided = {tuple(sorted(e["objects"])) for e in cev}
+    all_pairs = [tuple(sorted((a["idx"], b["idx"])))
+                 for i, a in enumerate(objs) for b in objs[i + 1:]]
+
+    def binary_q(pair, ans_yes, template):
+        a, b = pair
+        ch = ["yes", "no"]
+        rng.shuffle(ch)
+        ans = "yes" if ans_yes else "no"
+        return _q(f"Will {_ref(idx_of[a], objs)} collide with "
+                  f"{_ref(idx_of[b], objs)} by the end of the video?",
+                  ans, ch, ch.index(ans), "predictive", template,
+                  [{"op": "find_collision", "objects": [a, b]},
+                   {"op": "query_existence"}])
+
+    yes_pairs = [p for p in pairs_collided]
+    no_pairs = [p for p in all_pairs if p not in pairs_collided]
+    if yes_pairs:
+        p = yes_pairs[int(rng.integers(len(yes_pairs)))]
+        out.append(binary_q(p, True, "will_collide"))
+    if no_pairs:
+        p = no_pairs[int(rng.integers(len(no_pairs)))]
+        out.append(binary_q(p, False, "will_collide"))
+
+    # after colliding with b, will a collide with something else?
+    for e in cev:
+        a, b = e["objects"]
+        later = [x for x in cev if x is not e and a in x["objects"]
+                 and x["frame"] > e["frame"]]
+        if not later and len(cev) < 2:
+            continue
+        ans = "yes" if later else "no"
+        ch = ["yes", "no"]
+        rng.shuffle(ch)
+        out.append(_q(f"After {_coll_desc(objs, idx_of[a], idx_of[b])}, "
+                      f"will {_ref(idx_of[a], objs)} collide with something else?",
+                      ans, ch, ch.index(ans), "predictive", "will_collide_again",
+                      [{"op": "find_collision", "objects": [a, b]},
+                       {"op": "query_subsequent_collision"}]))
+    return out
+
+
+# --------------------------------------------------------------------------
+# counterfactual questions (re-simulate the scene with one object removed)
+# --------------------------------------------------------------------------
+
+def _counterfactual(objs, ev, rng, num_frames):
+    out = []
+    cev = ev["collisions"]
+    if not cev or len(objs) < 3:
+        return out
+    idx_of = {o["idx"]: o for o in objs}
+    refc = {o["idx"]: _ref(o, objs) for o in objs}
+
+    cache = {}
+
+    def cf_events(z):
+        if z not in cache:
+            cache[z] = simulate.resimulate_without(
+                [dict(s) for s in objs], z, num_frames)
+        return cache[z]
+
+    def binary(ans_yes, question, template, program):
+        ch = ["yes", "no"]
+        rng.shuffle(ch)
+        ans = "yes" if ans_yes else "no"
+        out.append(_q(question, ans, ch, ch.index(ans), "counterfactual",
+                      template, program))
+
+    # would a still collide with b without z?
+    for e in cev:
+        a, b = e["objects"]
+        others = [o["idx"] for o in objs if o["idx"] not in (a, b)]
+        for z in others:
+            cf = cf_events(z)
+            still = any(set(x["objects"]) == {a, b} for x in cf["collisions"])
+            binary(still,
+                   f"If {refc[z]} were removed, would {refc[a]} still collide "
+                   f"with {refc[b]}?",
+                   "cf_collision",
+                   [{"op": "remove_object", "idx": z},
+                    {"op": "find_collision", "objects": [a, b]},
+                    {"op": "query_existence"}])
+
+    # would o still start moving without z (z can be its collision partner)?
+    for o_idx, sts in ev["starts"].items():
+        if not sts or o_idx not in idx_of:
+            continue
+        partners = set()
+        for e in cev:
+            if o_idx in e["objects"]:
+                partners |= {p for p in e["objects"] if p != o_idx}
+        others = list(partners) + [o["idx"] for o in objs
+                                   if o["idx"] not in {o_idx} | partners]
+        for z in dict.fromkeys(others):
+            cf = cf_events(z)
+            still = (o_idx in cf["initially_moving"]) or bool(cf["starts"].get(o_idx))
+            binary(still,
+                   f"If {refc[z]} were removed, would {refc[o_idx]} still "
+                   f"start moving?",
+                   "cf_motion",
+                   [{"op": "remove_object", "idx": z},
+                    {"op": "filter_object", "idx": o_idx},
+                    {"op": "query_motion_start"}])
+    return out
+
+
+# --------------------------------------------------------------------------
+# orchestration
+# --------------------------------------------------------------------------
+
+def build_questions(spec, ev, rng, num_frames, max_questions=8):
+    """Return a list of question dicts sampled across the 4 CLEVRER types."""
+    objs = [s for s in spec if not s.get("is_probe")]
+    probe_idx = {s["idx"] for s in spec if s.get("is_probe")}
+
+    if probe_idx:  # drop probe objects from question-relevant events
+        ev = {
+            "collisions": [e for e in ev["collisions"] if not probe_idx & set(e["objects"])],
+            "starts": {k: v for k, v in ev["starts"].items() if k not in probe_idx},
+            "stops": {k: v for k, v in ev["stops"].items() if k not in probe_idx},
+            "initially_moving": [k for k in ev["initially_moving"] if k not in probe_idx],
+            "moving": ev["moving"],
+            "speeds": ev["speeds"],
+            "wall_hits": [w for w in ev["wall_hits"] if w[1] not in probe_idx],
+        }
+
+    pools = {
+        "descriptive": _descriptive(objs, ev, rng),
+        "explanatory": _explanatory(objs, ev, rng),
+        "predictive": _predictive(objs, ev, rng),
+        "counterfactual": _counterfactual(objs, ev, rng, num_frames),
+    }
+
+    quotas = [("descriptive", 3), ("explanatory", 2),
+              ("predictive", 1), ("counterfactual", 2)]
+    picked, seen = [], set()
+
+    def take(pool, k):
+        pool = [q for q in pool if q["question"] not in seen]
+        rng.shuffle(pool)
+        for q in pool[:k]:
+            seen.add(q["question"])
+            picked.append(q)
+
+    for qtype, k in quotas:
+        take(pools[qtype], k)
+    leftover = [q for pool in pools.values() for q in pool
+                if q["question"] not in seen]
+    rng.shuffle(leftover)
+    for q in leftover:
+        if len(picked) >= max_questions:
+            break
+        seen.add(q["question"])
+        picked.append(q)
+
+    rng.shuffle(picked)
+    return picked

clevrer_lite/renderer.py

@@ -0,0 +1,104 @@
+"""Top-down PIL renderer for the 2D CLEVRER-lite world.
+
+Sphere  -> shaded disc with a specular highlight
+Cube    -> rotated square with beveled edges
+Cylinder-> ring (dark side + lighter top face), as seen from above
+Metal   -> brighter material with a strong specular; rubber is matte.
+"""
+
+import numpy as np
+from PIL import Image, ImageDraw
+
+from . import config
+
+_LIGHT = np.array([-0.6, -0.8])   # light comes from top-left
+
+
+def _shade(rgb, factor):
+    return tuple(int(min(255, max(0, c * factor))) for c in rgb)
+
+
+def _background(size):
+    top = np.array([128.0, 128.0, 133.0])
+    bot = np.array([100.0, 100.0, 106.0])
+    rows = np.linspace(0.0, 1.0, size)[:, None]
+    grad = top[None, :] * (1.0 - rows) + bot[None, :] * rows      # (size, 3)
+    arr = np.repeat(grad[:, None, :], size, axis=1)               # (size, size, 3)
+    return arr.astype(np.uint8)
+
+
+def render(bodies, size: int = 128, half: float = config.WORLD_HALF) -> np.ndarray:
+    """Render a list of Body objects into an (size, size, 3) uint8 array."""
+    ss = 2                                   # 2x supersampling for anti-aliasing
+    S = size * ss
+    scale = S / (2.0 * half)
+
+    def to_px(p):
+        return (p[0] + half) * scale, (half - p[1]) * scale  # flip y: +y is "behind"
+
+    img = Image.fromarray(_background(S), "RGB")
+
+    # ---- soft ground shadows (drawn on an RGBA overlay) ----
+    shadow = Image.new("RGBA", (S, S), (0, 0, 0, 0))
+    sd = ImageDraw.Draw(shadow)
+    off = 0.05 * scale
+    for b in bodies:
+        cx, cy = to_px(b.pos)
+        r = b.radius * scale
+        sd.ellipse([cx - r + off, cy - r + off * 0.5, cx + r + off, cy + r + off * 0.5],
+                   fill=(15, 15, 20, 60))
+    img = Image.alpha_composite(img.convert("RGBA"), shadow).convert("RGB")
+
+    d = ImageDraw.Draw(img)
+    spec = Image.new("RGBA", (S, S), (0, 0, 0, 0))
+    spd = ImageDraw.Draw(spec)
+
+    for b in sorted(bodies, key=lambda x: -x.radius):
+        base = np.array(config.COLORS[b.color], dtype=float)
+        if b.material == "metal":
+            base = np.clip(base * 1.25 + 28, 0, 255)
+        base = tuple(int(c) for c in base)
+        cx, cy = to_px(b.pos)
+        r = b.radius * scale
+
+        if b.shape == "sphere":
+            d.ellipse([cx - r, cy - r, cx + r, cy + r], fill=_shade(base, 0.72))
+            d.ellipse([cx - 0.92 * r, cy - 0.92 * r, cx + 0.92 * r, cy + 0.92 * r],
+                      fill=base)
+            hi_a = 210 if b.material == "metal" else 90
+            spd.ellipse([cx - 0.45 * r, cy - 0.55 * r, cx - 0.05 * r, cy - 0.15 * r],
+                        fill=(255, 255, 255, hi_a))
+
+        elif b.shape == "cube":
+            hs = r * 0.88                       # half side s.t. area ~ circle
+            ang = b.angle
+            ca, sa = np.cos(ang), np.sin(ang)
+            corners = []
+            for dx, dy in ((-1, -1), (1, -1), (1, 1), (-1, 1)):
+                corners.append((cx + hs * (dx * ca - dy * sa),
+                                cy + hs * (dx * sa + dy * ca)))
+            d.polygon(corners, fill=base)
+            # bevel: edges facing the light are bright, others dark
+            for k in range(4):
+                a_, b_ = corners[k], corners[(k + 1) % 4]
+                ex, ey = b_[0] - a_[0], b_[1] - a_[1]
+                ln = np.hypot(ex, ey) + 1e-9
+                nx, ny = -ey / ln, ex / ln       # outward normal (polygon is CCW on screen)
+                if nx * _LIGHT[0] + ny * _LIGHT[1] < 0:
+                    col = _shade(base, 1.45 if b.material == "metal" else 1.22)
+                else:
+                    col = _shade(base, 0.55)
+                d.line([a_, b_], fill=col, width=max(2, int(0.06 * r)))
+
+        else:  # cylinder seen from above: dark rim + lighter top face
+            d.ellipse([cx - r, cy - r, cx + r, cy + r], fill=_shade(base, 0.62))
+            d.ellipse([cx - 0.78 * r, cy - 0.78 * r, cx + 0.78 * r, cy + 0.78 * r],
+                      fill=base)
+            spd.ellipse([cx - 0.5 * r, cy - 0.55 * r, cx - 0.1 * r, cy - 0.2 * r],
+                        fill=(255, 255, 255, 200 if b.material == "metal" else 70))
+
+    img = Image.alpha_composite(img.convert("RGBA"), spec).convert("RGB")
+
+    # downsample for anti-aliasing
+    img = img.resize((size, size), Image.LANCZOS)
+    return np.asarray(img, dtype=np.uint8)

clevrer_lite/simulate.py

@@ -0,0 +1,153 @@
+"""Scene sampling, deterministic rollout, and counterfactual re-simulation."""
+
+import numpy as np
+
+from . import config, physics, events as events_mod
+
+
+# --------------------------------------------------------------------------
+# scene specification (serializable dicts) <-> Body objects
+# --------------------------------------------------------------------------
+
+def sample_spec(rng, n_objects=None, probe=False):
+    """Sample a random CLEVRER-style scene spec (list of dicts)."""
+    n = int(n_objects if n_objects is not None else rng.integers(3, 7))  # 3..6
+    colors = rng.permutation(config.COLOR_NAMES)[:n]          # unique colors
+    shapes = rng.choice(config.SHAPES, size=n)
+    materials = rng.choice(config.MATERIALS, size=n)
+    sizes = rng.choice(config.SIZES, size=n)
+
+    # non-overlapping positions (rejection sampling)
+    radii = np.array([rng.uniform(*config.SIZE_RADIUS[s]) for s in sizes])
+    positions = np.zeros((n, 2))
+    placed = 0
+    tries = 0
+    while placed < n:
+        tries += 1
+        if tries > 4000:
+            raise RuntimeError("could not place objects without overlap")
+        p = rng.uniform(-config.SPAWN_HALF, config.SPAWN_HALF, size=2)
+        ok = True
+        for k in range(placed):
+            if np.linalg.norm(p - positions[k]) < radii[k] + radii[placed] + 0.22:
+                ok = False
+                break
+        if ok:
+            positions[placed] = p
+            placed += 1
+
+    # at least 2 objects moving, at least one stationary (for causal questions)
+    n_moving = int(rng.integers(2, min(n, 4) + 1))
+    moving_idx = set(rng.permutation(n)[:n_moving].tolist())
+
+    spec = []
+    for i in range(n):
+        v = np.zeros(2)
+        if i in moving_idx:
+            theta = rng.uniform(0, 2 * np.pi)
+            speed = rng.uniform(*config.SPEED_RANGE)
+            v = np.array([np.cos(theta), np.sin(theta)]) * speed
+        spec.append({
+            "idx": i,
+            "color": str(colors[i]),
+            "shape": str(shapes[i]),
+            "material": str(materials[i]),
+            "size": str(sizes[i]),
+            "radius": float(radii[i]),
+            "position": positions[i].tolist(),
+            "velocity": v.tolist(),
+            "spin": float(rng.uniform(-1.5, 1.5)),
+            "is_probe": False,
+        })
+
+    if probe:
+        theta = rng.uniform(0, 2 * np.pi)
+        spec.append({
+            "idx": n, "color": config.PROBE_COLOR, "shape": "sphere",
+            "material": "metal", "size": config.PROBE_SIZE,
+            "radius": config.PROBE_RADIUS,
+            "position": rng.uniform(-config.SPAWN_HALF, config.SPAWN_HALF, size=2).tolist(),
+            "velocity": [0.0, 0.0],
+            "spin": 0.0, "is_probe": True,
+        })
+    return spec
+
+
+def bodies_from_spec(spec):
+    from dataclasses import fields as dc_fields
+    bodies = []
+    for s in spec:
+        kwargs = {k: s[k] for k in ("idx", "color", "shape", "material", "size",
+                                    "radius", "spin", "is_probe")}
+        kwargs["pos"] = np.array(s["position"], dtype=float)
+        kwargs["vel"] = np.array(s["velocity"], dtype=float)
+        kwargs["mass"] = physics.mass_of(s["radius"], s["material"])
+        kwargs["angle"] = 0.0
+        bodies.append(physics.Body(**kwargs))
+    return bodies
+
+
+def spec_of(bodies):
+    return [{
+        "idx": b.idx, "color": b.color, "shape": b.shape, "material": b.material,
+        "size": b.size, "radius": float(b.radius),
+        "position": b.pos.tolist(), "velocity": b.vel.tolist(),
+        "spin": float(b.spin), "is_probe": b.is_probe,
+    } for b in bodies]
+
+
+# --------------------------------------------------------------------------
+# rollout
+# --------------------------------------------------------------------------
+
+def rollout(bodies, num_frames, render_fn=None, action_fn=None):
+    """Run a deterministic rollout (physics never uses RNG).
+
+    Args:
+        bodies: list[Body] (mutated in place).
+        num_frames: number of rendered frames.
+        render_fn: optional callable(bodies) -> frame array.
+        action_fn: optional callable(t, bodies) applied at the start of frame t
+                   (used by the gym env for probe-ball actions).
+
+    Returns:
+        dict with states (T, n, 4), collisions [(t, i, j)], wall_hits [(t, i, ax, s)],
+        and frames (T, H, W, 3) if render_fn was given.
+    """
+    world = physics.World(bodies)
+    n = len(bodies)
+    states = np.zeros((num_frames, n, 4), dtype=float)
+    collisions, wall_hits = [], []
+    frames = [] if render_fn is not None else None
+
+    for t in range(num_frames):
+        if action_fn is not None:
+            action_fn(t, bodies)
+        for _ in range(config.SUBSTEPS):
+            contacts, hits = world.step(config.SUB_DT)
+            for (i, j) in contacts:
+                collisions.append((t, i, j))
+            for (i, ax, s) in hits:
+                wall_hits.append((t, i, ax, s))
+        for k, b in enumerate(bodies):
+            states[t, k] = (b.pos[0], b.pos[1], b.vel[0], b.vel[1])
+        if render_fn is not None:
+            frames.append(render_fn(bodies))
+
+    return {"states": states, "collisions": collisions, "wall_hits": wall_hits,
+            "frames": frames}
+
+
+# --------------------------------------------------------------------------
+# counterfactual re-simulation (the CLEVRER trick: remove an object, re-run)
+# --------------------------------------------------------------------------
+
+def resimulate_without(spec, removed_idx, num_frames):
+    """Deep-copy the scene minus one object, re-run physics, extract events."""
+    import copy
+    spec2 = copy.deepcopy([s for s in spec if s["idx"] != removed_idx])
+    bodies = bodies_from_spec(spec2)
+    out = rollout(bodies, num_frames, render_fn=None)
+    ev = events_mod.extract_events(out["states"], out["collisions"],
+                                   out["wall_hits"], n=len(bodies))
+    return ev

output/annotations.json

@@ -0,0 +1,3237 @@
+[
+  {
+    "video_index": 0,
+    "video_filename": "videos/video_00000.gif",
+    "num_frames": 64,
+    "frame_size": 128,
+    "fps": 25,
+    "scene": {
+      "objects": [
+        {
+          "idx": 0,
+          "color": "blue",
+          "shape": "cube",
+          "material": "metal",
+          "size": "small",
+          "radius": 0.14201513451832787,
+          "position": [
+            -0.23966961428725875,
+            -1.462209019449065
+          ],
+          "velocity": [
+            -0.8609936860984196,
+            -0.5796115807438419
+          ],
+          "spin": -0.3251429984155163,
+          "is_probe": false
+        },
+        {
+          "idx": 1,
+          "color": "brown",
+          "shape": "cylinder",
+          "material": "metal",
+          "size": "large",
+          "radius": 0.31837243571439555,
+          "position": [
+            -1.164721842851352,
+            0.5289356855502538
+          ],
+          "velocity": [
+            0.0,
+            0.0
+          ],
+          "spin": 1.170823056014377,
+          "is_probe": false
+        },
+        {
+          "idx": 2,
+          "color": "green",
+          "shape": "sphere",
+          "material": "metal",
+          "size": "large",
+          "radius": 0.27405244964820474,
+          "position": [
+            0.4562874858801751,
+            0.357693845591887
+          ],
+          "velocity": [
+            0.18925657454551104,
+            1.3095824406480492
+          ],
+          "spin": -1.2479539692528454,
+          "is_probe": false
+        },
+        {
+          "idx": 3,
+          "color": "cyan",
+          "shape": "cylinder",
+          "material": "metal",
+          "size": "small",
+          "radius": 0.1917907353409932,
+          "position": [
+            -0.3605995817881613,
+            1.5413508009465542
+          ],
+          "velocity": [
+            0.0,
+            0.0
+          ],
+          "spin": 0.9979324429601935,
+          "is_probe": false
+        },
+        {
+          "idx": 4,
+          "color": "purple",
+          "shape": "sphere",
+          "material": "metal",
+          "size": "small",
+          "radius": 0.1724876732149455,
+          "position": [
+            1.4905895502063131,
+            0.5751801518901536
+          ],
+          "velocity": [
+            0.0,
+            0.0
+          ],
+          "spin": 0.8612949224660502,
+          "is_probe": false
+        },
+        {
+          "idx": 5,
+          "color": "gray",
+          "shape": "sphere",
+          "material": "metal",
+          "size": "large",
+          "radius": 0.28397695124299077,
+          "position": [
+            1.2074122864819008,
+            1.345534899464374
+          ],
+          "velocity": [
+            0.10522102901322228,
+            1.5729688697009279
+          ],
+          "spin": -1.324295895584417,
+          "is_probe": false
+        }
+      ]
+    },
+    "events": {
+      "collision_events": [
+        {
+          "frame": 19,
+          "objects": [
+            4,
+            5
+          ],
+          "description": "the purple sphere collided with the gray sphere"
+        },
+        {
+          "frame": 61,
+          "objects": [
+            2,
+            5
+          ],
+          "description": "the green sphere collided with the gray sphere"
+        }
+      ],
+      "motion_events": [
+        {
+          "object": 4,
+          "type": "start",
+          "frame": 19,
+          "cause_collision": {
+            "frame": 19,
+            "objects": [
+              4,
+              5
+            ]
+          }
+        }
+      ],
+      "initially_moving": [
+        0,
+        2,
+        5
+      ]
+    },
+    "raw_events": {
+      "collisions": [
+        {
+          "frame": 19,
+          "objects": [
+            4,
+            5
+          ]
+        },
+        {
+          "frame": 61,
+          "objects": [
+            2,
+            5
+          ]
+        }
+      ],
+      "starts": {
+        "0": [],
+        "1": [],
+        "2": [],
+        "3": [],
+        "4": [
+          19
+        ],
+        "5": []
+      },
+      "stops": {
+        "0": [],
+        "1": [],
+        "2": [],
+        "3": [],
+        "4": [],
+        "5": []
+      },
+      "initially_moving": [
+        0,
+        2,
+        5
+      ],
+      "wall_hits": [
+        [
+          5,
+          5,
+          1,
+          1
+        ],
+        [
+          17,
+          0,
+          1,
+          -1
+        ],
+        [
+          27,
+          2,
+          1,
+          1
+        ],
+        [
+          30,
+          4,
+          0,
+          1
+        ],
+        [
+          52,
+          0,
+          0,
+          -1
+        ],
+        [
+          62,
+          4,
+          1,
+          -1
+        ]
+      ]
+    },
+    "questions": [
+      {
+        "question": "Will the green sphere collide with the gray sphere by the end of the video?",
+        "answer": "yes",
+        "choices": [
+          "yes",
+          "no"
+        ],
+        "answer_index": 0,
+        "question_type": "predictive",
+        "template": "will_collide",
+        "program": [
+          {
+            "op": "find_collision",
+            "objects": [
+              2,
+              5
+            ]
+          },
+          {
+            "op": "query_existence"
+          }
+        ]
+      },
+      {
+        "question": "If the cyan cylinder were removed, would the purple sphere still collide with the gray sphere?",
+        "answer": "yes",
+        "choices": [
+          "no",
+          "yes"
+        ],
+        "answer_index": 1,
+        "question_type": "counterfactual",
+        "template": "cf_collision",
+        "program": [
+          {
+            "op": "remove_object",
+            "idx": 3
+          },
+          {
+            "op": "find_collision",
+            "objects": [
+              4,
+              5
+            ]
+          },
+          {
+            "op": "query_existence"
+          }
+        ]
+      },
+      {
+        "question": "What happened right before the green sphere collided with the gray sphere?",
+        "answer": "the purple sphere collided with the gray sphere",
+        "choices": [
+          "the purple sphere collided with the wall",
+          "the purple sphere started moving",
+          "the purple sphere collided with the gray sphere",
+          "nothing happened"
+        ],
+        "answer_index": 2,
+        "question_type": "explanatory",
+        "template": "what_happened_before",
+        "program": [
+          {
+            "op": "find_collision",
+            "objects": [
+              2,
+              5
+            ]
+          },
+          {
+            "op": "query_before_event"
+          }
+        ]
+      },
+      {
+        "question": "What shape is the green object?",
+        "answer": "sphere",
+        "choices": [
+          "cube",
+          "sphere",
+          "cylinder"
+        ],
+        "answer_index": 1,
+        "question_type": "descriptive",
+        "template": "query_shape",
+        "program": [
+          {
+            "op": "filter_color",
+            "value": "green"
+          },
+          {
+            "op": "query_shape"
+          }
+        ]
+      },
+      {
+        "question": "What shape is the blue object?",
+        "answer": "cube",
+        "choices": [
+          "cylinder",
+          "sphere",
+          "cube"
+        ],
+        "answer_index": 2,
+        "question_type": "descriptive",
+        "template": "query_shape",
+        "program": [
+          {
+            "op": "filter_color",
+            "value": "blue"
+          },
+          {
+            "op": "query_shape"
+          }
+        ]
+      },
+      {
+        "question": "What color is the object left of the blue cube?",
+        "answer": "brown",
+        "choices": [
+          "cyan",
+          "green",
+          "gray",
+          "red",
+          "brown",
+          "blue",
+          "yellow",
+          "purple"
+        ],
+        "answer_index": 4,
+        "question_type": "descriptive",
+        "template": "query_color_rel",
+        "program": [
+          {
+            "op": "filter_color",
+            "value": "blue"
+          },
+          {
+            "op": "relate",
+            "direction": "left_of"
+          },
+          {
+            "op": "query_color"
+          }
+        ]
+      },
+      {
+        "question": "If the cyan cylinder were removed, would the purple sphere still start moving?",
+        "answer": "yes",
+        "choices": [
+          "no",
+          "yes"
+        ],
+        "answer_index": 1,
+        "question_type": "counterfactual",
+        "template": "cf_motion",
+        "program": [
+          {
+            "op": "remove_object",
+            "idx": 3
+          },
+          {
+            "op": "filter_object",
+            "idx": 4
+          },
+          {
+            "op": "query_motion_start"
+          }
+        ]
+      },
+      {
+        "question": "How many objects were moving when the purple sphere collided with the gray sphere?",
+        "answer": "4",
+        "choices": [
+          "0",
+          "1",
+          "2",
+          "3",
+          "4",
+          "5"
+        ],
+        "answer_index": 4,
+        "question_type": "explanatory",
+        "template": "count_moving_at",
+        "program": [
+          {
+            "op": "find_collision",
+            "objects": [
+              4,
+              5
+            ]
+          },
+          {
+            "op": "count_moving_at_collision"
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "video_index": 1,
+    "video_filename": "videos/video_00001.gif",
+    "num_frames": 64,
+    "frame_size": 128,
+    "fps": 25,
+    "scene": {
+      "objects": [
+        {
+          "idx": 0,
+          "color": "purple",
+          "shape": "cylinder",
+          "material": "rubber",
+          "size": "small",
+          "radius": 0.17228859879315672,
+          "position": [
+            -0.14415654260998023,
+            -1.1344707385337893
+          ],
+          "velocity": [
+            0.0,
+            0.0
+          ],
+          "spin": -0.6693263878638875,
+          "is_probe": false
+        },
+        {
+          "idx": 1,
+          "color": "gray",
+          "shape": "sphere",
+          "material": "rubber",
+          "size": "small",
+          "radius": 0.15978390298994555,
+          "position": [
+            -0.7368286446302665,
+            0.776130485153163
+          ],
+          "velocity": [
+            0.8890070987191017,
+            1.4136185002086372
+          ],
+          "spin": 0.04820575664363602,
+          "is_probe": false
+        },
+        {
+          "idx": 2,
+          "color": "red",
+          "shape": "cube",
+          "material": "metal",
+          "size": "large",
+          "radius": 0.32307429627427237,
+          "position": [
+            -0.6807328502432762,
+            -0.04590797926193124
+          ],
+          "velocity": [
+            0.0,
+            0.0
+          ],
+          "spin": -1.1524031625876892,
+          "is_probe": false
+        },
+        {
+          "idx": 3,
+          "color": "brown",
+          "shape": "cylinder",
+          "material": "metal",
+          "size": "large",
+          "radius": 0.2842555863433316,
+          "position": [
+            1.4902853193838397,
+            1.431137300357739
+          ],
+          "velocity": [
+            -1.0540337912642956,
+            -1.03421747570648
+          ],
+          "spin": 0.3390099031591214,
+          "is_probe": false
+        }
+      ]
+    },
+    "events": {
+      "collision_events": [
+        {
+          "frame": 40,
+          "objects": [
+            2,
+            3
+          ],
+          "description": "the red cube collided with the brown cylinder"
+        },
+        {
+          "frame": 55,
+          "objects": [
+            0,
+            3
+          ],
+          "description": "the purple cylinder collided with the brown cylinder"
+        }
+      ],
+      "motion_events": [
+        {
+          "object": 0,
+          "type": "start",
+          "frame": 55,
+          "cause_collision": {
+            "frame": 55,
+            "objects": [
+              0,
+              3
+            ]
+          }
+        },
+        {
+          "object": 2,
+          "type": "start",
+          "frame": 40,
+          "cause_collision": {
+            "frame": 40,
+            "objects": [
+              2,
+              3
+            ]
+          }
+        }
+      ],
+      "initially_moving": [
+        1,
+        3
+      ]
+    },
+    "raw_events": {
+      "collisions": [
+        {
+          "frame": 40,
+          "objects": [
+            2,
+            3
+          ]
+        },
+        {
+          "frame": 55,
+          "objects": [
+            0,
+            3
+          ]
+        }
+      ],
+      "starts": {
+        "0": [
+          55
+        ],
+        "1": [],
+        "2": [
+          40
+        ],
+        "3": []
+      },
+      "stops": {
+        "0": [],
+        "1": [],
+        "2": [],
+        "3": []
+      },
+      "initially_moving": [
+        1,
+        3
+      ],
+      "wall_hits": [
+        [
+          19,
+          1,
+          1,
+          1
+        ]
+      ]
+    },
+    "questions": [
+      {
+        "question": "After the red cube collided with the brown cylinder, will the red cube collide with something else?",
+        "answer": "no",
+        "choices": [
+          "no",
+          "yes"
+        ],
+        "answer_index": 0,
+        "question_type": "predictive",
+        "template": "will_collide_again",
+        "program": [
+          {
+            "op": "find_collision",
+            "objects": [
+              2,
+              3
+            ]
+          },
+          {
+            "op": "query_subsequent_collision"
+          }
+        ]
+      },
+      {
+        "question": "What caused the purple cylinder to start moving?",
+        "answer": "the collision with the brown cylinder",
+        "choices": [
+          "it was pushed by the wall",
+          "nothing - it was already moving",
+          "the collision with the red cube",
+          "the collision with the brown cylinder"
+        ],
+        "answer_index": 3,
+        "question_type": "explanatory",
+        "template": "cause_of_motion",
+        "program": [
+          {
+            "op": "filter_object",
+            "idx": 0
+          },
+          {
+            "op": "query_motion_cause"
+          }
+        ]
+      },
+      {
+        "question": "If the brown cylinder were removed, would the purple cylinder still start moving?",
+        "answer": "no",
+        "choices": [
+          "yes",
+          "no"
+        ],
+        "answer_index": 1,
+        "question_type": "counterfactual",
+        "template": "cf_motion",
+        "program": [
+          {
+            "op": "remove_object",
+            "idx": 3
+          },
+          {
+            "op": "filter_object",
+            "idx": 0
+          },
+          {
+            "op": "query_motion_start"
+          }
+        ]
+      },
+      {
+        "question": "If the gray sphere were removed, would the purple cylinder still collide with the brown cylinder?",
+        "answer": "yes",
+        "choices": [
+          "no",
+          "yes"
+        ],
+        "answer_index": 1,
+        "question_type": "counterfactual",
+        "template": "cf_collision",
+        "program": [
+          {
+            "op": "remove_object",
+            "idx": 1
+          },
+          {
+            "op": "find_collision",
+            "objects": [
+              0,
+              3
+            ]
+          },
+          {
+            "op": "query_existence"
+          }
+        ]
+      },
+      {
+        "question": "How many objects are there?",
+        "answer": "4",
+        "choices": [
+          "0",
+          "1",
+          "2",
+          "3",
+          "4",
+          "5"
+        ],
+        "answer_index": 4,
+        "question_type": "descriptive",
+        "template": "count_all",
+        "program": [
+          {
+            "op": "count"
+          }
+        ]
+      },
+      {
+        "question": "How many sphere objects are there?",
+        "answer": "1",
+        "choices": [
+          "0",
+          "1",
+          "3",
+          "4",
+          "5",
+          "6"
+        ],
+        "answer_index": 1,
+        "question_type": "descriptive",
+        "template": "count_shape",
+        "program": [
+          {
+            "op": "filter_shape",
+            "value": "sphere"
+          },
+          {
+            "op": "count"
+          }
+        ]
+      },
+      {
+        "question": "How many collisions happened in the video?",
+        "answer": "2",
+        "choices": [
+          "0",
+          "1",
+          "2",
+          "3",
+          "5",
+          "6"
+        ],
+        "answer_index": 2,
+        "question_type": "explanatory",
+        "template": "count_collisions",
+        "program": [
+          {
+            "op": "filter_event",
+            "type": "collision"
+          },
+          {
+            "op": "count"
+          }
+        ]
+      },
+      {
+        "question": "What shape is the gray object?",
+        "answer": "sphere",
+        "choices": [
+          "cube",
+          "cylinder",
+          "sphere"
+        ],
+        "answer_index": 2,
+        "question_type": "descriptive",
+        "template": "query_shape",
+        "program": [
+          {
+            "op": "filter_color",
+            "value": "gray"
+          },
+          {
+            "op": "query_shape"
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "video_index": 2,
+    "video_filename": "videos/video_00002.gif",
+    "num_frames": 64,
+    "frame_size": 128,
+    "fps": 25,
+    "scene": {
+      "objects": [
+        {
+          "idx": 0,
+          "color": "blue",
+          "shape": "cylinder",
+          "material": "rubber",
+          "size": "large",
+          "radius": 0.33739487619949415,
+          "position": [
+            1.2127491694517956,
+            0.8542482216653375
+          ],
+          "velocity": [
+            -0.36715859956078306,
+            -0.9719919196853971
+          ],
+          "spin": 0.0684855117712917,
+          "is_probe": false
+        },
+        {
+          "idx": 1,
+          "color": "yellow",
+          "shape": "cube",
+          "material": "metal",
+          "size": "large",
+          "radius": 0.31464518578477,
+          "position": [
+            -0.5637455380923395,
+            1.315072379171155
+          ],
+          "velocity": [
+            0.16865636414440546,
+            0.7827396049255161
+          ],
+          "spin": -1.3841876102370936,
+          "is_probe": false
+        },
+        {
+          "idx": 2,
+          "color": "cyan",
+          "shape": "sphere",
+          "material": "rubber",
+          "size": "large",
+          "radius": 0.2913299866464021,
+          "position": [
+            -0.09017935521115161,
+            0.6006524108269133
+          ],
+          "velocity": [
+            -0.3438585017186605,
+            -1.104125496358226
+          ],
+          "spin": 1.1932024412795266,
+          "is_probe": false
+        },
+        {
+          "idx": 3,
+          "color": "purple",
+          "shape": "cube",
+          "material": "rubber",
+          "size": "small",
+          "radius": 0.1512351541832059,
+          "position": [
+            -1.2176573437938771,
+            -1.2259149688578814
+          ],
+          "velocity": [
+            0.0,
+            0.0
+          ],
+          "spin": 1.005549614076839,
+          "is_probe": false
+        },
+        {
+          "idx": 4,
+          "color": "red",
+          "shape": "cube",
+          "material": "metal",
+          "size": "small",
+          "radius": 0.160757639934304,
+          "position": [
+            0.44775243453710445,
+            -0.2897185672058369
+          ],
+          "velocity": [
+            0.0,
+            0.0
+          ],
+          "spin": -0.3447145965575502,
+          "is_probe": false
+        },
+        {
+          "idx": 5,
+          "color": "green",
+          "shape": "sphere",
+          "material": "rubber",
+          "size": "large",
+          "radius": 0.3008852778855662,
+          "position": [
+            1.1225657532136475,
+            -0.19162288490671253
+          ],
+          "velocity": [
+            0.0,
+            0.0
+          ],
+          "spin": 1.421036309115669,
+          "is_probe": false
+        }
+      ]
+    },
+    "events": {
+      "collision_events": [
+        {
+          "frame": 10,
+          "objects": [
+            0,
+            5
+          ],
+          "description": "the blue cylinder collided with the green sphere"
+        },
+        {
+          "frame": 48,
+          "objects": [
+            0,
+            4
+          ],
+          "description": "the blue cylinder collided with the red cube"
+        },
+        {
+          "frame": 57,
+          "objects": [
+            0,
+            1
+          ],
+          "description": "the blue cylinder collided with the yellow cube"
+        },
+        {
+          "frame": 61,
+          "objects": [
+            0,
+            4
+          ],
+          "description": "the blue cylinder collided with the red cube"
+        }
+      ],
+      "motion_events": [
+        {
+          "object": 4,
+          "type": "start",
+          "frame": 48,
+          "cause_collision": {
+            "frame": 48,
+            "objects": [
+              0,
+              4
+            ]
+          }
+        },
+        {
+          "object": 5,
+          "type": "start",
+          "frame": 10,
+          "cause_collision": {
+            "frame": 10,
+            "objects": [
+              0,
+              5
+            ]
+          }
+        }
+      ],
+      "initially_moving": [
+        0,
+        1,
+        2
+      ]
+    },
+    "raw_events": {
+      "collisions": [
+        {
+          "frame": 10,
+          "objects": [
+            0,
+            5
+          ]
+        },
+        {
+          "frame": 48,
+          "objects": [
+            0,
+            4
+          ]
+        },
+        {
+          "frame": 57,
+          "objects": [
+            0,
+            1
+          ]
+        },
+        {
+          "frame": 61,
+          "objects": [
+            0,
+            4
+          ]
+        }
+      ],
+      "starts": {
+        "0": [],
+        "1": [],
+        "2": [],
+        "3": [],
+        "4": [
+          48
+        ],
+        "5": [
+          10
+        ]
+      },
+      "stops": {
+        "0": [],
+        "1": [],
+        "2": [],
+        "3": [],
+        "4": [],
+        "5": []
+      },
+      "initially_moving": [
+        0,
+        1,
+        2
+      ],
+      "wall_hits": [
+        [
+          12,
+          1,
+          1,
+          1
+        ],
+        [
+          53,
+          5,
+          1,
+          -1
+        ],
+        [
+          58,
+          2,
+          1,
+          -1
+        ]
+      ]
+    },
+    "questions": [
+      {
+        "question": "What happened right after the blue cylinder collided with the red cube?",
+        "answer": "nothing happened",
+        "choices": [
+          "the yellow cube collided with the wall",
+          "nothing happened",
+          "the cyan sphere collided with the wall",
+          "the blue cylinder collided with the green sphere"
+        ],
+        "answer_index": 1,
+        "question_type": "explanatory",
+        "template": "what_happened_after",
+        "program": [
+          {
+            "op": "find_collision",
+            "objects": [
+              0,
+              4
+            ]
+          },
+          {
+            "op": "query_after_event"
+          }
+        ]
+      },
+      {
+        "question": "If the green sphere were removed, would the blue cylinder still collide with the red cube?",
+        "answer": "yes",
+        "choices": [
+          "yes",
+          "no"
+        ],
+        "answer_index": 0,
+        "question_type": "counterfactual",
+        "template": "cf_collision",
+        "program": [
+          {
+            "op": "remove_object",
+            "idx": 5
+          },
+          {
+            "op": "find_collision",
+            "objects": [
+              0,
+              4
+            ]
+          },
+          {
+            "op": "query_existence"
+          }
+        ]
+      },
+      {
+        "question": "If the red cube were removed, would the blue cylinder still collide with the yellow cube?",
+        "answer": "yes",
+        "choices": [
+          "yes",
+          "no"
+        ],
+        "answer_index": 0,
+        "question_type": "counterfactual",
+        "template": "cf_collision",
+        "program": [
+          {
+            "op": "remove_object",
+            "idx": 4
+          },
+          {
+            "op": "find_collision",
+            "objects": [
+              0,
+              1
+            ]
+          },
+          {
+            "op": "query_existence"
+          }
+        ]
+      },
+      {
+        "question": "What material is the yellow cube made of?",
+        "answer": "metal",
+        "choices": [
+          "rubber",
+          "metal"
+        ],
+        "answer_index": 1,
+        "question_type": "descriptive",
+        "template": "query_material",
+        "program": [
+          {
+            "op": "filter_color",
+            "value": "yellow"
+          },
+          {
+            "op": "filter_shape",
+            "value": "cube"
+          },
+          {
+            "op": "query_material"
+          }
+        ]
+      },
+      {
+        "question": "How many purple objects are there?",
+        "answer": "1",
+        "choices": [
+          "0",
+          "1",
+          "2",
+          "3",
+          "4",
+          "6"
+        ],
+        "answer_index": 1,
+        "question_type": "descriptive",
+        "template": "count_color",
+        "program": [
+          {
+            "op": "filter_color",
+            "value": "purple"
+          },
+          {
+            "op": "count"
+          }
+        ]
+      },
+      {
+        "question": "After the blue cylinder collided with the red cube, will the blue cylinder collide with something else?",
+        "answer": "yes",
+        "choices": [
+          "yes",
+          "no"
+        ],
+        "answer_index": 0,
+        "question_type": "predictive",
+        "template": "will_collide_again",
+        "program": [
+          {
+            "op": "find_collision",
+            "objects": [
+              0,
+              4
+            ]
+          },
+          {
+            "op": "query_subsequent_collision"
+          }
+        ]
+      },
+      {
+        "question": "How many objects were moving when the blue cylinder collided with the red cube?",
+        "answer": "5",
+        "choices": [
+          "0",
+          "1",
+          "3",
+          "4",
+          "5",
+          "6"
+        ],
+        "answer_index": 4,
+        "question_type": "explanatory",
+        "template": "count_moving_at",
+        "program": [
+          {
+            "op": "find_collision",
+            "objects": [
+              0,
+              4
+            ]
+          },
+          {
+            "op": "count_moving_at_collision"
+          }
+        ]
+      },
+      {
+        "question": "What shape is the purple object?",
+        "answer": "cube",
+        "choices": [
+          "cylinder",
+          "sphere",
+          "cube"
+        ],
+        "answer_index": 2,
+        "question_type": "descriptive",
+        "template": "query_shape",
+        "program": [
+          {
+            "op": "filter_color",
+            "value": "purple"
+          },
+          {
+            "op": "query_shape"
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "video_index": 3,
+    "video_filename": "videos/video_00003.gif",
+    "num_frames": 64,
+    "frame_size": 128,
+    "fps": 25,
+    "scene": {
+      "objects": [
+        {
+          "idx": 0,
+          "color": "yellow",
+          "shape": "cube",
+          "material": "metal",
+          "size": "large",
+          "radius": 0.3190270229833728,
+          "position": [
+            -1.545380741122608,
+            1.4677268517758797
+          ],
+          "velocity": [
+            0.653208134845669,
+            -1.1901842959224622
+          ],
+          "spin": 0.5483967235810505,
+          "is_probe": false
+        },
+        {
+          "idx": 1,
+          "color": "gray",
+          "shape": "sphere",
+          "material": "metal",
+          "size": "large",
+          "radius": 0.3365013803868879,
+          "position": [
+            -0.6249562086476854,
+            -0.576643393693556
+          ],
+          "velocity": [
+            0.0,
+            0.0
+          ],
+          "spin": 0.960227250511605,
+          "is_probe": false
+        },
+        {
+          "idx": 2,
+          "color": "blue",
+          "shape": "sphere",
+          "material": "rubber",
+          "size": "small",
+          "radius": 0.1570520698249275,
+          "position": [
+            1.2143043183799873,
+            0.2640051136618149
+          ],
+          "velocity": [
+            0.0,
+            0.0
+          ],
+          "spin": -0.21428128710461403,
+          "is_probe": false
+        },
+        {
+          "idx": 3,
+          "color": "red",
+          "shape": "sphere",
+          "material": "rubber",
+          "size": "small",
+          "radius": 0.1789128324247895,
+          "position": [
+            -0.08894003793632277,
+            0.847158729911331
+          ],
+          "velocity": [
+            0.0,
+            0.0
+          ],
+          "spin": 0.7761163834647569,
+          "is_probe": false
+        },
+        {
+          "idx": 4,
+          "color": "brown",
+          "shape": "cube",
+          "material": "rubber",
+          "size": "large",
+          "radius": 0.31569727973361245,
+          "position": [
+            0.49755020902647407,
+            1.3375379496981992
+          ],
+          "velocity": [
+            0.0,
+            0.0
+          ],
+          "spin": 1.1354405539987615,
+          "is_probe": false
+        },
+        {
+          "idx": 5,
+          "color": "cyan",
+          "shape": "cube",
+          "material": "rubber",
+          "size": "large",
+          "radius": 0.283417659920999,
+          "position": [
+            -0.9077073789488962,
+            0.40327961933456313
+          ],
+          "velocity": [
+            1.2403780112124232,
+            0.9291094064281774
+          ],
+          "spin": -0.31821800210299456,
+          "is_probe": false
+        }
+      ]
+    },
+    "events": {
+      "collision_events": [
+        {
+          "frame": 7,
+          "objects": [
+            3,
+            5
+          ],
+          "description": "the red sphere collided with the cyan cube"
+        },
+        {
+          "frame": 11,
+          "objects": [
+            3,
+            4
+          ],
+          "description": "the red sphere collided with the brown cube"
+        },
+        {
+          "frame": 31,
+          "objects": [
+            0,
+            1
+          ],
+          "description": "the yellow cube collided with the gray sphere"
+        }
+      ],
+      "motion_events": [
+        {
+          "object": 1,
+          "type": "start",
+          "frame": 31,
+          "cause_collision": {
+            "frame": 31,
+            "objects": [
+              0,
+              1
+            ]
+          }
+        },
+        {
+          "object": 3,
+          "type": "start",
+          "frame": 7,
+          "cause_collision": {
+            "frame": 7,
+            "objects": [
+              3,
+              5
+            ]
+          }
+        },
+        {
+          "object": 4,
+          "type": "start",
+          "frame": 11,
+          "cause_collision": {
+            "frame": 11,
+            "objects": [
+              3,
+              4
+            ]
+          }
+        }
+      ],
+      "initially_moving": [
+        0,
+        5
+      ]
+    },
+    "raw_events": {
+      "collisions": [
+        {
+          "frame": 7,
+          "objects": [
+            3,
+            5
+          ]
+        },
+        {
+          "frame": 11,
+          "objects": [
+            3,
+            4
+          ]
+        },
+        {
+          "frame": 31,
+          "objects": [
+            0,
+            1
+          ]
+        }
+      ],
+      "starts": {
+        "0": [],
+        "1": [
+          31
+        ],
+        "2": [],
+        "3": [
+          7
+        ],
+        "4": [
+          11
+        ],
+        "5": []
+      },
+      "stops": {
+        "0": [],
+        "1": [],
+        "2": [],
+        "3": [],
+        "4": [],
+        "5": []
+      },
+      "initially_moving": [
+        0,
+        5
+      ],
+      "wall_hits": [
+        [
+          26,
+          4,
+          1,
+          1
+        ],
+        [
+          51,
+          5,
+          1,
+          1
+        ],
+        [
+          59,
+          1,
+          1,
+          -1
+        ]
+      ]
+    },
+    "questions": [
+      {
+        "question": "If the cyan cube were removed, would the red sphere still start moving?",
+        "answer": "no",
+        "choices": [
+          "yes",
+          "no"
+        ],
+        "answer_index": 1,
+        "question_type": "counterfactual",
+        "template": "cf_motion",
+        "program": [
+          {
+            "op": "remove_object",
+            "idx": 5
+          },
+          {
+            "op": "filter_object",
+            "idx": 3
+          },
+          {
+            "op": "query_motion_start"
+          }
+        ]
+      },
+      {
+        "question": "If the blue sphere were removed, would the red sphere still collide with the cyan cube?",
+        "answer": "yes",
+        "choices": [
+          "yes",
+          "no"
+        ],
+        "answer_index": 0,
+        "question_type": "counterfactual",
+        "template": "cf_collision",
+        "program": [
+          {
+            "op": "remove_object",
+            "idx": 2
+          },
+          {
+            "op": "find_collision",
+            "objects": [
+              3,
+              5
+            ]
+          },
+          {
+            "op": "query_existence"
+          }
+        ]
+      },
+      {
+        "question": "How many red objects are there?",
+        "answer": "1",
+        "choices": [
+          "1",
+          "2",
+          "3",
+          "4",
+          "5",
+          "6"
+        ],
+        "answer_index": 0,
+        "question_type": "descriptive",
+        "template": "count_color",
+        "program": [
+          {
+            "op": "filter_color",
+            "value": "red"
+          },
+          {
+            "op": "count"
+          }
+        ]
+      },
+      {
+        "question": "What happened right after the red sphere collided with the cyan cube?",
+        "answer": "the red sphere collided with the brown cube",
+        "choices": [
+          "the red sphere collided with the brown cube",
+          "the yellow cube collided with the gray sphere",
+          "nothing happened",
+          "the cyan cube collided with the wall"
+        ],
+        "answer_index": 0,
+        "question_type": "explanatory",
+        "template": "what_happened_after",
+        "program": [
+          {
+            "op": "find_collision",
+            "objects": [
+              3,
+              5
+            ]
+          },
+          {
+            "op": "query_after_event"
+          }
+        ]
+      },
+      {
+        "question": "Will the red sphere collide with the cyan cube by the end of the video?",
+        "answer": "yes",
+        "choices": [
+          "no",
+          "yes"
+        ],
+        "answer_index": 1,
+        "question_type": "predictive",
+        "template": "will_collide",
+        "program": [
+          {
+            "op": "find_collision",
+            "objects": [
+              3,
+              5
+            ]
+          },
+          {
+            "op": "query_existence"
+          }
+        ]
+      },
+      {
+        "question": "What happened right after the red sphere collided with the brown cube?",
+        "answer": "the yellow cube collided with the gray sphere",
+        "choices": [
+          "nothing happened",
+          "the gray sphere started moving",
+          "the brown cube started moving",
+          "the yellow cube collided with the gray sphere"
+        ],
+        "answer_index": 3,
+        "question_type": "explanatory",
+        "template": "what_happened_after",
+        "program": [
+          {
+            "op": "find_collision",
+            "objects": [
+              3,
+              4
+            ]
+          },
+          {
+            "op": "query_after_event"
+          }
+        ]
+      },
+      {
+        "question": "What material is the brown cube made of?",
+        "answer": "rubber",
+        "choices": [
+          "metal",
+          "rubber"
+        ],
+        "answer_index": 1,
+        "question_type": "descriptive",
+        "template": "query_material",
+        "program": [
+          {
+            "op": "filter_color",
+            "value": "brown"
+          },
+          {
+            "op": "filter_shape",
+            "value": "cube"
+          },
+          {
+            "op": "query_material"
+          }
+        ]
+      },
+      {
+        "question": "What color is the object in front of the blue sphere?",
+        "answer": "gray",
+        "choices": [
+          "blue",
+          "yellow",
+          "gray",
+          "brown",
+          "cyan",
+          "red",
+          "purple",
+          "green"
+        ],
+        "answer_index": 2,
+        "question_type": "descriptive",
+        "template": "query_color_rel",
+        "program": [
+          {
+            "op": "filter_color",
+            "value": "blue"
+          },
+          {
+            "op": "relate",
+            "direction": "in_front_of"
+          },
+          {
+            "op": "query_color"
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "video_index": 4,
+    "video_filename": "videos/video_00004.gif",
+    "num_frames": 64,
+    "frame_size": 128,
+    "fps": 25,
+    "scene": {
+      "objects": [
+        {
+          "idx": 0,
+          "color": "red",
+          "shape": "sphere",
+          "material": "metal",
+          "size": "small",
+          "radius": 0.1658297766637648,
+          "position": [
+            1.3299818020728005,
+            -0.9991529841378586
+          ],
+          "velocity": [
+            0.0,
+            0.0
+          ],
+          "spin": -0.07188326857379423,
+          "is_probe": false
+        },
+        {
+          "idx": 1,
+          "color": "cyan",
+          "shape": "sphere",
+          "material": "metal",
+          "size": "large",
+          "radius": 0.3231157374035464,
+          "position": [
+            0.3374400122180976,
+            0.635080711250702
+          ],
+          "velocity": [
+            0.0,
+            0.0
+          ],
+          "spin": -0.8490599207340147,
+          "is_probe": false
+        },
+        {
+          "idx": 2,
+          "color": "blue",
+          "shape": "cube",
+          "material": "rubber",
+          "size": "small",
+          "radius": 0.1990491799958673,
+          "position": [
+            1.3726914053004184,
+            0.5135379925938357
+          ],
+          "velocity": [
+            -0.519380992006974,
+            -1.3758624215162312
+          ],
+          "spin": -0.9276344842243871,
+          "is_probe": false
+        },
+        {
+          "idx": 3,
+          "color": "gray",
+          "shape": "sphere",
+          "material": "metal",
+          "size": "large",
+          "radius": 0.28957806341219433,
+          "position": [
+            -1.1364731580997514,
+            -0.006610443765339147
+          ],
+          "velocity": [
+            -1.0283166962197308,
+            0.26460535465147544
+          ],
+          "spin": -0.9878105416611754,
+          "is_probe": false
+        },
+        {
+          "idx": 4,
+          "color": "yellow",
+          "shape": "sphere",
+          "material": "metal",
+          "size": "small",
+          "radius": 0.1981359721589741,
+          "position": [
+            0.254248982005842,
+            -0.7197164900960757
+          ],
+          "velocity": [
+            0.2976426213341292,
+            1.6356465885638267
+          ],
+          "spin": 1.152669154895344,
+          "is_probe": false
+        }
+      ]
+    },
+    "events": {
+      "collision_events": [
+        {
+          "frame": 13,
+          "objects": [
+            1,
+            4
+          ],
+          "description": "the cyan sphere collided with the yellow sphere"
+        },
+        {
+          "frame": 50,
+          "objects": [
+            0,
+            4
+          ],
+          "description": "the red sphere collided with the yellow sphere"
+        }
+      ],
+      "motion_events": [
+        {
+          "object": 0,
+          "type": "start",
+          "frame": 50,
+          "cause_collision": {
+            "frame": 50,
+            "objects": [
+              0,
+              4
+            ]
+          }
+        },
+        {
+          "object": 1,
+          "type": "start",
+          "frame": 13,
+          "cause_collision": {
+            "frame": 13,
+            "objects": [
+              1,
+              4
+            ]
+          }
+        }
+      ],
+      "initially_moving": [
+        2,
+        3,
+        4
+      ]
+    },
+    "raw_events": {
+      "collisions": [
+        {
+          "frame": 13,
+          "objects": [
+            1,
+            4
+          ]
+        },
+        {
+          "frame": 50,
+          "objects": [
+            0,
+            4
+          ]
+        }
+      ],
+      "starts": {
+        "0": [
+          50
+        ],
+        "1": [
+          13
+        ],
+        "2": [],
+        "3": [],
+        "4": []
+      },
+      "stops": {
+        "0": [],
+        "1": [],
+        "2": [],
+        "3": [],
+        "4": []
+      },
+      "initially_moving": [
+        2,
+        3,
+        4
+      ],
+      "wall_hits": [
+        [
+          14,
+          3,
+          0,
+          -1
+        ],
+        [
+          46,
+          2,
+          1,
+          -1
+        ],
+        [
+          48,
+          1,
+          1,
+          1
+        ]
+      ]
+    },
+    "questions": [
+      {
+        "question": "What happened right after the cyan sphere collided with the yellow sphere?",
+        "answer": "the red sphere collided with the yellow sphere",
+        "choices": [
+          "the red sphere started moving",
+          "the red sphere collided with the yellow sphere",
+          "the cyan sphere started moving",
+          "the gray sphere collided with the wall"
+        ],
+        "answer_index": 1,
+        "question_type": "explanatory",
+        "template": "what_happened_after",
+        "program": [
+          {
+            "op": "find_collision",
+            "objects": [
+              1,
+              4
+            ]
+          },
+          {
+            "op": "query_after_event"
+          }
+        ]
+      },
+      {
+        "question": "If the cyan sphere were removed, would the red sphere still start moving?",
+        "answer": "no",
+        "choices": [
+          "no",
+          "yes"
+        ],
+        "answer_index": 0,
+        "question_type": "counterfactual",
+        "template": "cf_motion",
+        "program": [
+          {
+            "op": "remove_object",
+            "idx": 1
+          },
+          {
+            "op": "filter_object",
+            "idx": 0
+          },
+          {
+            "op": "query_motion_start"
+          }
+        ]
+      },
+      {
+        "question": "What shape is the cyan object?",
+        "answer": "sphere",
+        "choices": [
+          "sphere",
+          "cylinder",
+          "cube"
+        ],
+        "answer_index": 0,
+        "question_type": "descriptive",
+        "template": "query_shape",
+        "program": [
+          {
+            "op": "filter_color",
+            "value": "cyan"
+          },
+          {
+            "op": "query_shape"
+          }
+        ]
+      },
+      {
+        "question": "What shape is the red object?",
+        "answer": "sphere",
+        "choices": [
+          "cube",
+          "cylinder",
+          "sphere"
+        ],
+        "answer_index": 2,
+        "question_type": "descriptive",
+        "template": "query_shape",
+        "program": [
+          {
+            "op": "filter_color",
+            "value": "red"
+          },
+          {
+            "op": "query_shape"
+          }
+        ]
+      },
+      {
+        "question": "If the yellow sphere were removed, would the red sphere still start moving?",
+        "answer": "no",
+        "choices": [
+          "yes",
+          "no"
+        ],
+        "answer_index": 1,
+        "question_type": "counterfactual",
+        "template": "cf_motion",
+        "program": [
+          {
+            "op": "remove_object",
+            "idx": 4
+          },
+          {
+            "op": "filter_object",
+            "idx": 0
+          },
+          {
+            "op": "query_motion_start"
+          }
+        ]
+      },
+      {
+        "question": "What caused the red sphere to start moving?",
+        "answer": "the collision with the yellow sphere",
+        "choices": [
+          "the collision with the cyan sphere",
+          "the collision with the yellow sphere",
+          "nothing - it was already moving",
+          "it was pushed by the wall"
+        ],
+        "answer_index": 1,
+        "question_type": "explanatory",
+        "template": "cause_of_motion",
+        "program": [
+          {
+            "op": "filter_object",
+            "idx": 0
+          },
+          {
+            "op": "query_motion_cause"
+          }
+        ]
+      },
+      {
+        "question": "What shape is the yellow object?",
+        "answer": "sphere",
+        "choices": [
+          "sphere",
+          "cube",
+          "cylinder"
+        ],
+        "answer_index": 0,
+        "question_type": "descriptive",
+        "template": "query_shape",
+        "program": [
+          {
+            "op": "filter_color",
+            "value": "yellow"
+          },
+          {
+            "op": "query_shape"
+          }
+        ]
+      },
+      {
+        "question": "Will the red sphere collide with the cyan sphere by the end of the video?",
+        "answer": "no",
+        "choices": [
+          "yes",
+          "no"
+        ],
+        "answer_index": 1,
+        "question_type": "predictive",
+        "template": "will_collide",
+        "program": [
+          {
+            "op": "find_collision",
+            "objects": [
+              0,
+              1
+            ]
+          },
+          {
+            "op": "query_existence"
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "video_index": 5,
+    "video_filename": "videos/video_00005.gif",
+    "num_frames": 64,
+    "frame_size": 128,
+    "fps": 25,
+    "scene": {
+      "objects": [
+        {
+          "idx": 0,
+          "color": "red",
+          "shape": "cylinder",
+          "material": "rubber",
+          "size": "small",
+          "radius": 0.16609685313350853,
+          "position": [
+            -0.02162864193159808,
+            0.5477369906763048
+          ],
+          "velocity": [
+            0.0,
+            0.0
+          ],
+          "spin": -1.496400949239514,
+          "is_probe": false
+        },
+        {
+          "idx": 1,
+          "color": "brown",
+          "shape": "cube",
+          "material": "rubber",
+          "size": "large",
+          "radius": 0.33793489546074046,
+          "position": [
+            -1.3615115898300263,
+            0.17234796245424255
+          ],
+          "velocity": [
+            -1.1364131596450517,
+            -0.02402328219120739
+          ],
+          "spin": -0.8902414916563056,
+          "is_probe": false
+        },
+        {
+          "idx": 2,
+          "color": "blue",
+          "shape": "cube",
+          "material": "rubber",
+          "size": "small",
+          "radius": 0.19386065648651293,
+          "position": [
+            -0.7085000259566853,
+            1.1769186373382585
+          ],
+          "velocity": [
+            0.0,
+            0.0
+          ],
+          "spin": -0.5251720662731818,
+          "is_probe": false
+        },
+        {
+          "idx": 3,
+          "color": "green",
+          "shape": "sphere",
+          "material": "rubber",
+          "size": "large",
+          "radius": 0.3275384830086993,
+          "position": [
+            1.1472743572152606,
+            -0.8453125720011849
+          ],
+          "velocity": [
+            0.0,
+            0.0
+          ],
+          "spin": 0.9186459930811308,
+          "is_probe": false
+        },
+        {
+          "idx": 4,
+          "color": "gray",
+          "shape": "sphere",
+          "material": "rubber",
+          "size": "large",
+          "radius": 0.2913923731467823,
+          "position": [
+            1.2258895421837905,
+            1.1538059508754384
+          ],
+          "velocity": [
+            -0.34428904618230377,
+            0.7761002312894555
+          ],
+          "spin": 0.5955359709549324,
+          "is_probe": false
+        }
+      ]
+    },
+    "events": {
+      "collision_events": [
+        {
+          "frame": 43,
+          "objects": [
+            0,
+            1
+          ],
+          "description": "the red cylinder collided with the brown cube"
+        },
+        {
+          "frame": 52,
+          "objects": [
+            0,
+            4
+          ],
+          "description": "the red cylinder collided with the gray sphere"
+        }
+      ],
+      "motion_events": [
+        {
+          "object": 0,
+          "type": "start",
+          "frame": 43,
+          "cause_collision": {
+            "frame": 43,
+            "objects": [
+              0,
+              1
+            ]
+          }
+        }
+      ],
+      "initially_moving": [
+        1,
+        4
+      ]
+    },
+    "raw_events": {
+      "collisions": [
+        {
+          "frame": 43,
+          "objects": [
+            0,
+            1
+          ]
+        },
+        {
+          "frame": 52,
+          "objects": [
+            0,
+            4
+          ]
+        }
+      ],
+      "starts": {
+        "0": [
+          43
+        ],
+        "1": [],
+        "2": [],
+        "3": [],
+        "4": []
+      },
+      "stops": {
+        "0": [],
+        "1": [],
+        "2": [],
+        "3": [],
+        "4": []
+      },
+      "initially_moving": [
+        1,
+        4
+      ],
+      "wall_hits": [
+        [
+          6,
+          1,
+          0,
+          -1
+        ],
+        [
+          18,
+          4,
+          1,
+          1
+        ]
+      ]
+    },
+    "questions": [
+      {
+        "question": "How many red objects are there?",
+        "answer": "1",
+        "choices": [
+          "0",
+          "1",
+          "2",
+          "3",
+          "4",
+          "6"
+        ],
+        "answer_index": 1,
+        "question_type": "descriptive",
+        "template": "count_color",
+        "program": [
+          {
+            "op": "filter_color",
+            "value": "red"
+          },
+          {
+            "op": "count"
+          }
+        ]
+      },
+      {
+        "question": "How many green objects are there?",
+        "answer": "1",
+        "choices": [
+          "0",
+          "1",
+          "3",
+          "4",
+          "5",
+          "6"
+        ],
+        "answer_index": 1,
+        "question_type": "descriptive",
+        "template": "count_color",
+        "program": [
+          {
+            "op": "filter_color",
+            "value": "green"
+          },
+          {
+            "op": "count"
+          }
+        ]
+      },
+      {
+        "question": "After the red cylinder collided with the gray sphere, will the red cylinder collide with something else?",
+        "answer": "no",
+        "choices": [
+          "no",
+          "yes"
+        ],
+        "answer_index": 0,
+        "question_type": "predictive",
+        "template": "will_collide_again",
+        "program": [
+          {
+            "op": "find_collision",
+            "objects": [
+              0,
+              4
+            ]
+          },
+          {
+            "op": "query_subsequent_collision"
+          }
+        ]
+      },
+      {
+        "question": "If the gray sphere were removed, would the red cylinder still collide with the brown cube?",
+        "answer": "yes",
+        "choices": [
+          "no",
+          "yes"
+        ],
+        "answer_index": 1,
+        "question_type": "counterfactual",
+        "template": "cf_collision",
+        "program": [
+          {
+            "op": "remove_object",
+            "idx": 4
+          },
+          {
+            "op": "find_collision",
+            "objects": [
+              0,
+              1
+            ]
+          },
+          {
+            "op": "query_existence"
+          }
+        ]
+      },
+      {
+        "question": "How many collisions happened in the video?",
+        "answer": "2",
+        "choices": [
+          "0",
+          "1",
+          "2",
+          "3",
+          "4",
+          "6"
+        ],
+        "answer_index": 2,
+        "question_type": "explanatory",
+        "template": "count_collisions",
+        "program": [
+          {
+            "op": "filter_event",
+            "type": "collision"
+          },
+          {
+            "op": "count"
+          }
+        ]
+      },
+      {
+        "question": "If the green sphere were removed, would the red cylinder still start moving?",
+        "answer": "yes",
+        "choices": [
+          "yes",
+          "no"
+        ],
+        "answer_index": 0,
+        "question_type": "counterfactual",
+        "template": "cf_motion",
+        "program": [
+          {
+            "op": "remove_object",
+            "idx": 3
+          },
+          {
+            "op": "filter_object",
+            "idx": 0
+          },
+          {
+            "op": "query_motion_start"
+          }
+        ]
+      },
+      {
+        "question": "What material is the brown cube made of?",
+        "answer": "rubber",
+        "choices": [
+          "rubber",
+          "metal"
+        ],
+        "answer_index": 0,
+        "question_type": "descriptive",
+        "template": "query_material",
+        "program": [
+          {
+            "op": "filter_color",
+            "value": "brown"
+          },
+          {
+            "op": "filter_shape",
+            "value": "cube"
+          },
+          {
+            "op": "query_material"
+          }
+        ]
+      },
+      {
+        "question": "What happened right before the red cylinder collided with the brown cube?",
+        "answer": "nothing happened",
+        "choices": [
+          "the brown cube collided with the wall",
+          "the gray sphere collided with the wall",
+          "nothing happened",
+          "the red cylinder collided with the gray sphere"
+        ],
+        "answer_index": 2,
+        "question_type": "explanatory",
+        "template": "what_happened_before",
+        "program": [
+          {
+            "op": "find_collision",
+            "objects": [
+              0,
+              1
+            ]
+          },
+          {
+            "op": "query_before_event"
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "video_index": 6,
+    "video_filename": "videos/video_00006.gif",
+    "num_frames": 64,
+    "frame_size": 128,
+    "fps": 25,
+    "scene": {
+      "objects": [
+        {
+          "idx": 0,
+          "color": "gray",
+          "shape": "cylinder",
+          "material": "metal",
+          "size": "large",
+          "radius": 0.30582561130513064,
+          "position": [
+            1.015313310209694,
+            1.530768557963947
+          ],
+          "velocity": [
+            0.9319215143021138,
+            1.3700450324185096
+          ],
+          "spin": 1.4610128175207322,
+          "is_probe": false
+        },
+        {
+          "idx": 1,
+          "color": "green",
+          "shape": "cube",
+          "material": "rubber",
+          "size": "small",
+          "radius": 0.15881747166108884,
+          "position": [
+            1.0384166676550775,
+            -1.366283580995418
+          ],
+          "velocity": [
+            -0.13504772072375007,
+            1.651824808022114
+          ],
+          "spin": -0.8753456925925228,
+          "is_probe": false
+        },
+        {
+          "idx": 2,
+          "color": "yellow",
+          "shape": "sphere",
+          "material": "rubber",
+          "size": "small",
+          "radius": 0.18688395948884723,
+          "position": [
+            1.1539508850452902,
+            -0.025816298556336603
+          ],
+          "velocity": [
+            1.2339526958730866,
+            0.7270782658906909
+          ],
+          "spin": 0.9492184377530788,
+          "is_probe": false
+        }
+      ]
+    },
+    "events": {
+      "collision_events": [
+        {
+          "frame": 18,
+          "objects": [
+            0,
+            2
+          ],
+          "description": "the gray cylinder collided with the yellow sphere"
+        },
+        {
+          "frame": 30,
+          "objects": [
+            0,
+            1
+          ],
+          "description": "the gray cylinder collided with the green cube"
+        }
+      ],
+      "motion_events": [],
+      "initially_moving": [
+        0,
+        1,
+        2
+      ]
+    },
+    "raw_events": {
+      "collisions": [
+        {
+          "frame": 18,
+          "objects": [
+            0,
+            2
+          ]
+        },
+        {
+          "frame": 30,
+          "objects": [
+            0,
+            1
+          ]
+        }
+      ],
+      "starts": {
+        "0": [],
+        "1": [],
+        "2": []
+      },
+      "stops": {
+        "0": [],
+        "1": [],
+        "2": []
+      },
+      "initially_moving": [
+        0,
+        1,
+        2
+      ],
+      "wall_hits": [
+        [
+          2,
+          0,
+          1,
+          1
+        ],
+        [
+          13,
+          2,
+          0,
+          1
+        ],
+        [
+          18,
+          0,
+          0,
+          1
+        ],
+        [
+          46,
+          2,
+          1,
+          -1
+        ]
+      ]
+    },
+    "questions": [
+      {
+        "question": "If the yellow sphere were removed, would the gray cylinder still collide with the green cube?",
+        "answer": "no",
+        "choices": [
+          "yes",
+          "no"
+        ],
+        "answer_index": 1,
+        "question_type": "counterfactual",
+        "template": "cf_collision",
+        "program": [
+          {
+            "op": "remove_object",
+            "idx": 2
+          },
+          {
+            "op": "find_collision",
+            "objects": [
+              0,
+              1
+            ]
+          },
+          {
+            "op": "query_existence"
+          }
+        ]
+      },
+      {
+        "question": "After the gray cylinder collided with the yellow sphere, will the gray cylinder collide with something else?",
+        "answer": "yes",
+        "choices": [
+          "yes",
+          "no"
+        ],
+        "answer_index": 0,
+        "question_type": "predictive",
+        "template": "will_collide_again",
+        "program": [
+          {
+            "op": "find_collision",
+            "objects": [
+              0,
+              2
+            ]
+          },
+          {
+            "op": "query_subsequent_collision"
+          }
+        ]
+      },
+      {
+        "question": "How many yellow objects are there?",
+        "answer": "1",
+        "choices": [
+          "0",
+          "1",
+          "3",
+          "4",
+          "5",
+          "6"
+        ],
+        "answer_index": 1,
+        "question_type": "descriptive",
+        "template": "count_color",
+        "program": [
+          {
+            "op": "filter_color",
+            "value": "yellow"
+          },
+          {
+            "op": "count"
+          }
+        ]
+      },
+      {
+        "question": "If the green cube were removed, would the gray cylinder still collide with the yellow sphere?",
+        "answer": "yes",
+        "choices": [
+          "yes",
+          "no"
+        ],
+        "answer_index": 0,
+        "question_type": "counterfactual",
+        "template": "cf_collision",
+        "program": [
+          {
+            "op": "remove_object",
+            "idx": 1
+          },
+          {
+            "op": "find_collision",
+            "objects": [
+              0,
+              2
+            ]
+          },
+          {
+            "op": "query_existence"
+          }
+        ]
+      },
+      {
+        "question": "What color is the sphere?",
+        "answer": "yellow",
+        "choices": [
+          "yellow",
+          "blue",
+          "purple",
+          "brown",
+          "red",
+          "gray",
+          "cyan",
+          "green"
+        ],
+        "answer_index": 0,
+        "question_type": "descriptive",
+        "template": "query_color",
+        "program": [
+          {
+            "op": "filter_shape",
+            "value": "sphere"
+          },
+          {
+            "op": "query_color"
+          }
+        ]
+      },
+      {
+        "question": "How many objects were moving when the gray cylinder collided with the green cube?",
+        "answer": "3",
+        "choices": [
+          "0",
+          "1",
+          "2",
+          "3"
+        ],
+        "answer_index": 3,
+        "question_type": "explanatory",
+        "template": "count_moving_at",
+        "program": [
+          {
+            "op": "find_collision",
+            "objects": [
+              0,
+              1
+            ]
+          },
+          {
+            "op": "count_moving_at_collision"
+          }
+        ]
+      },
+      {
+        "question": "What material is the gray cylinder made of?",
+        "answer": "metal",
+        "choices": [
+          "rubber",
+          "metal"
+        ],
+        "answer_index": 1,
+        "question_type": "descriptive",
+        "template": "query_material",
+        "program": [
+          {
+            "op": "filter_color",
+            "value": "gray"
+          },
+          {
+            "op": "filter_shape",
+            "value": "cylinder"
+          },
+          {
+            "op": "query_material"
+          }
+        ]
+      },
+      {
+        "question": "What happened right after the gray cylinder collided with the green cube?",
+        "answer": "nothing happened",
+        "choices": [
+          "the gray cylinder collided with the wall",
+          "the yellow sphere collided with the wall",
+          "the gray cylinder collided with the yellow sphere",
+          "nothing happened"
+        ],
+        "answer_index": 3,
+        "question_type": "explanatory",
+        "template": "what_happened_after",
+        "program": [
+          {
+            "op": "find_collision",
+            "objects": [
+              0,
+              1
+            ]
+          },
+          {
+            "op": "query_after_event"
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "video_index": 7,
+    "video_filename": "videos/video_00007.gif",
+    "num_frames": 64,
+    "frame_size": 128,
+    "fps": 25,
+    "scene": {
+      "objects": [
+        {
+          "idx": 0,
+          "color": "green",
+          "shape": "sphere",
+          "material": "metal",
+          "size": "small",
+          "radius": 0.16276677029301875,
+          "position": [
+            0.42778940044382985,
+            0.5469957558196439
+          ],
+          "velocity": [
+            -0.435788272762294,
+            -0.708289098056274
+          ],
+          "spin": 1.0352229626236586,
+          "is_probe": false
+        },
+        {
+          "idx": 1,
+          "color": "gray",
+          "shape": "sphere",
+          "material": "rubber",
+          "size": "small",
+          "radius": 0.19872487306467332,
+          "position": [
+            -1.0825571405780572,
+            -0.18502825171661863
+          ],
+          "velocity": [
+            0.0,
+            0.0
+          ],
+          "spin": 1.3348445134349385,
+          "is_probe": false
+        },
+        {
+          "idx": 2,
+          "color": "red",
+          "shape": "cube",
+          "material": "metal",
+          "size": "small",
+          "radius": 0.17539950158063664,
+          "position": [
+            -1.2502173088115887,
+            1.4502669582513465
+          ],
+          "velocity": [
+            0.0,
+            0.0
+          ],
+          "spin": 1.2117503645877803,
+          "is_probe": false
+        },
+        {
+          "idx": 3,
+          "color": "purple",
+          "shape": "cube",
+          "material": "rubber",
+          "size": "large",
+          "radius": 0.3084045003063881,
+          "position": [
+            -0.8834874841967719,
+            0.5324720040949835
+          ],
+          "velocity": [
+            -0.7656290826407781,
+            -0.358628834908836
+          ],
+          "spin": -0.9226095150950029,
+          "is_probe": false
+        }
+      ]
+    },
+    "events": {
+      "collision_events": [
+        {
+          "frame": 34,
+          "objects": [
+            1,
+            3
+          ],
+          "description": "the gray sphere collided with the purple cube"
+        },
+        {
+          "frame": 50,
+          "objects": [
+            0,
+            1
+          ],
+          "description": "the green sphere collided with the gray sphere"
+        }
+      ],
+      "motion_events": [
+        {
+          "object": 1,
+          "type": "start",
+          "frame": 34,
+          "cause_collision": {
+            "frame": 34,
+            "objects": [
+              1,
+              3
+            ]
+          }
+        }
+      ],
+      "initially_moving": [
+        0,
+        3
+      ]
+    },
+    "raw_events": {
+      "collisions": [
+        {
+          "frame": 34,
+          "objects": [
+            1,
+            3
+          ]
+        },
+        {
+          "frame": 50,
+          "objects": [
+            0,
+            1
+          ]
+        }
+      ],
+      "starts": {
+        "0": [],
+        "1": [
+          34
+        ],
+        "2": [],
+        "3": []
+      },
+      "stops": {
+        "0": [],
+        "1": [],
+        "2": [],
+        "3": []
+      },
+      "initially_moving": [
+        0,
+        3
+      ],
+      "wall_hits": [
+        [
+          27,
+          3,
+          0,
+          -1
+        ]
+      ]
+    },
+    "questions": [
+      {
+        "question": "If the purple cube were removed, would the gray sphere still start moving?",
+        "answer": "no",
+        "choices": [
+          "no",
+          "yes"
+        ],
+        "answer_index": 0,
+        "question_type": "counterfactual",
+        "template": "cf_motion",
+        "program": [
+          {
+            "op": "remove_object",
+            "idx": 3
+          },
+          {
+            "op": "filter_object",
+            "idx": 1
+          },
+          {
+            "op": "query_motion_start"
+          }
+        ]
+      },
+      {
+        "question": "What happened right after the gray sphere collided with the purple cube?",
+        "answer": "the green sphere collided with the gray sphere",
+        "choices": [
+          "the green sphere collided with the gray sphere",
+          "the purple cube collided with the wall",
+          "the gray sphere started moving",
+          "nothing happened"
+        ],
+        "answer_index": 0,
+        "question_type": "explanatory",
+        "template": "what_happened_after",
+        "program": [
+          {
+            "op": "find_collision",
+            "objects": [
+              1,
+              3
+            ]
+          },
+          {
+            "op": "query_after_event"
+          }
+        ]
+      },
+      {
+        "question": "How many red objects are there?",
+        "answer": "1",
+        "choices": [
+          "0",
+          "1",
+          "2",
+          "4",
+          "5",
+          "6"
+        ],
+        "answer_index": 1,
+        "question_type": "descriptive",
+        "template": "count_color",
+        "program": [
+          {
+            "op": "filter_color",
+            "value": "red"
+          },
+          {
+            "op": "count"
+          }
+        ]
+      },
+      {
+        "question": "If the red cube were removed, would the gray sphere still collide with the purple cube?",
+        "answer": "yes",
+        "choices": [
+          "yes",
+          "no"
+        ],
+        "answer_index": 0,
+        "question_type": "counterfactual",
+        "template": "cf_collision",
+        "program": [
+          {
+            "op": "remove_object",
+            "idx": 2
+          },
+          {
+            "op": "find_collision",
+            "objects": [
+              1,
+              3
+            ]
+          },
+          {
+            "op": "query_existence"
+          }
+        ]
+      },
+      {
+        "question": "What color is the object in front of the purple cube?",
+        "answer": "gray",
+        "choices": [
+          "gray",
+          "red",
+          "blue",
+          "cyan",
+          "purple",
+          "green",
+          "yellow",
+          "brown"
+        ],
+        "answer_index": 0,
+        "question_type": "descriptive",
+        "template": "query_color_rel",
+        "program": [
+          {
+            "op": "filter_color",
+            "value": "purple"
+          },
+          {
+            "op": "relate",
+            "direction": "in_front_of"
+          },
+          {
+            "op": "query_color"
+          }
+        ]
+      },
+      {
+        "question": "How many cube objects are there?",
+        "answer": "2",
+        "choices": [
+          "1",
+          "2",
+          "3",
+          "4",
+          "5",
+          "6"
+        ],
+        "answer_index": 1,
+        "question_type": "descriptive",
+        "template": "count_shape",
+        "program": [
+          {
+            "op": "filter_shape",
+            "value": "cube"
+          },
+          {
+            "op": "count"
+          }
+        ]
+      },
+      {
+        "question": "How many collisions happened in the video?",
+        "answer": "2",
+        "choices": [
+          "0",
+          "1",
+          "2",
+          "3",
+          "4",
+          "6"
+        ],
+        "answer_index": 2,
+        "question_type": "explanatory",
+        "template": "count_collisions",
+        "program": [
+          {
+            "op": "filter_event",
+            "type": "collision"
+          },
+          {
+            "op": "count"
+          }
+        ]
+      },
+      {
+        "question": "Will the gray sphere collide with the red cube by the end of the video?",
+        "answer": "no",
+        "choices": [
+          "no",
+          "yes"
+        ],
+        "answer_index": 0,
+        "question_type": "predictive",
+        "template": "will_collide",
+        "program": [
+          {
+            "op": "find_collision",
+            "objects": [
+              1,
+              2
+            ]
+          },
+          {
+            "op": "query_existence"
+          }
+        ]
+      }
+    ]
+  }
+]