The Seriality Gap in Video Diffusion Models
Abstract: When one ball strikes another, then another, video models should predict the consequences of each bounce. In controlled experiments on multi-ball hard-sphere dynamics, we find that the performance of standard bidirectional video diffusion degrades as the causal chain lengthens, even when provided more denoising steps. In a length-matched single-ball control, where ball-ball interactions are absent, the degradation largely disappears, isolating dependent-event structure rather than video length as the cause. Across intervention studies, methods that increase effective serial computation improve performance disproportionately, including autoregressive/blockwise generation and architectural depth. We identify this pattern as the seriality gap: a mismatch between tasks requiring growing serial computation and video diffusion models whose denoising loop does not provide scalable serial compute. We then prove that, for deterministic video prediction, denoising steps do not add serial computation beyond the backbone, indicating a structural obstacle for video diffusion on serial reasoning and simulation tasks.
Paper Prompts
Sign up for free to create and run prompts on this paper using GPT-5.
Top Community Prompts
Explain it Like I'm 14
What is this paper about?
This paper asks a simple question: Can today’s video-making AI models correctly predict long chains of cause-and-effect events in a video, like a series of billiard balls bouncing into each other?
The authors find a consistent problem they call the “seriality gap.” As the chain of dependent events gets longer, standard video diffusion models make more mistakes—even if you give them more time to “polish” their outputs. However, making the model work more step-by-step or making it deeper helps a lot.
What are the main questions the paper tries to answer?
- Do video diffusion models stay accurate when they must predict longer chains of events, not just longer videos?
- Does giving the model more “denoising steps” (extra refinement passes) help it reason through longer cause-and-effect chains?
- Do methods that force the model to work more step-by-step (like predicting frame-by-frame) or adding more layers (depth) fix the problem?
- Why, in theory, don’t extra denoising steps act like extra “thinking steps” for this kind of task?
How did the authors test this?
To keep things simple and clear, the authors used a toy world: balls moving in a box and bouncing off walls and each other.
- Think of it like a simple video game: multiple identical colored balls glide and bounce. There’s no randomness and no fancy graphics—just clear physics.
- They gave the model a few starting frames and asked it to predict the future frames.
They created two versions:
- Several balls (e.g., 5 balls): Here, a ball hitting another changes what happens next, creating a chain of events. The longer the video, the longer the chain.
- One ball (control): With a single ball, there are no ball-to-ball collisions. The future is easy to calculate—no chain of dependent events.
They tried different ways to run the video diffusion model:
- Bidirectional denoising: The usual way—refine all future frames together, many times.
- Autoregressive and blockwise generation: Predict the future in small steps, e.g., a few frames at a time or frame-by-frame, so the model is forced to work in order.
- More denoising steps: Give the usual model extra refinement passes.
- Deeper vs. wider backbones: Increase the number of layers (depth) or the layer size (width) inside the model.
They measured:
- Position errors: How far the predicted ball positions are from the true positions.
- Short-term physics consistency: Does the model’s short-term motion match what the physics simulator would do?
- Shape quality: Are the balls rendered with the right shapes and sizes, independent of where they are?
In everyday terms: they checked if the model could keep track of where each ball should be after many bounces, if it followed the physics in the short term, and if the balls still looked like balls.
What did they find, and why does it matter?
Here are the key findings.
- Longer chains of events break the usual approach: In the multi-ball case, the standard bidirectional diffusion model got worse as the prediction needed more bounces (longer causal chains). But in the one-ball control (same video length, no collisions), this drop mostly disappeared. That means the real difficulty is the chain of dependent events, not just making a longer video.
- More polishing doesn’t fix it: Giving the bidirectional diffusion model more denoising steps helped a bit at first, but then stopped helping. Even many more steps didn’t close the gap when the chain got long.
- Step-by-step generation helps a lot: When they forced the model to generate the video in small time chunks—like solving a problem one step at a time—the predictions stayed more accurate over long chains. Fully frame-by-frame (autoregressive) worked best.
- Deeper beats wider: Adding more layers (depth) helped more than just making layers bigger (width). Deeper models, which can do more steps of internal processing, handled longer chains better.
- Typical mistakes looked like broken physics: The bidirectional model often showed “tunneling” (a ball passing through another), balls merging or splitting, or balls swapping colors—clearly impossible in the real physics of the setup.
Why it matters: Many real-world tasks rely on long chains of cause and effect—physics, planning, and reasoning. If a model can’t keep track of those chains, it may look good at first but fail on deeper consistency.
What’s the big idea behind the theory?
The authors explain why extra denoising steps don’t act like extra “thinking steps” for deterministic, fully observable video prediction (situations where the future is completely determined by the first few frames, like these bouncing balls).
- Imagine the future of the video is a single correct path. If the model perfectly knows the “direction to the answer” at any noise level (this is what the “score” represents in diffusion), then one perfect calculation already points straight to the right future. Doing more denoising steps won’t magically add more step-by-step reasoning—it’s just more polishing of the same information.
- In other words, the repeated denoising passes in a standard diffusion model don’t automatically provide the kind of serial, chain-by-chain computation that long cause-and-effect problems need.
- To handle long chains, you need either:
- A generation method that explicitly proceeds step-by-step (like autoregression), or
- A deeper model that carries out more internal computation per pass, or
- New kinds of generative models that are designed to perform and preserve useful intermediate computations across steps.
Why does this research matter in the bigger picture?
- For simulations and reasoning: If we want AI to act like a world simulator or a planner, it must keep track of long chains of cause and effect. This paper shows that the common way we use diffusion models can struggle with that.
- For model design: It suggests practical fixes—generate videos in smaller steps, use deeper architectures, or rethink models so their multiple steps actually perform cumulative reasoning, not just surface-level refinement.
- For future research: The “seriality gap” is likely to show up in other chain-of-reasoning tasks, like puzzles or mazes. Autoregression won’t always be the perfect fix, but the general lesson stands: tasks that need step-by-step thinking require models and inference procedures that provide it.
Knowledge Gaps
Knowledge gaps, limitations, and open questions
Below is a concise list of concrete gaps and open directions that remain unresolved by the paper and could guide future research.
- External validity beyond synthetic hard-sphere dynamics
- Do the findings generalize to visually complex, partially observable, and stochastic real-world video (e.g., natural scenes with occlusions, texture clutter, camera motion, lighting changes)?
- How does the seriality gap behave in 3D physics, deformable objects, friction/non-elastic collisions, and heterogeneous masses/radii?
- Dependency structures not aligned with time
- The study focuses on temporally ordered dependencies (collisions). Does the seriality gap persist in tasks where dependencies are non-local in time (e.g., global constraints, long-range planning in mazes/puzzles)?
- What inference factorizations (beyond frame-wise autoregression) best match non-temporal or graph-structured dependencies?
- Explicit control of dependency-chain length
- The study uses video length f and collision-density filtering as proxies for chain length. Can future datasets directly control or annotate the exact number and order of dependent events to isolate scaling with chain depth at fixed horizon?
- Scope of models evaluated
- Results are limited to DiT-style latent video diffusion (Wan2.1 VAE). Do the conclusions hold for other backbones (U-Nets, SSMs/recurrent transformers, hybrid AR–diffusion, memory-augmented models) and raw-pixel diffusion (no VAE compression)?
- How do state-space models or explicit recurrent architectures (with learned persistent state) compare when dependency chains grow?
- Denoising-iteration design space
- The negative result for more steps is shown for standard denoising loops. Can step-coupled architectures (e.g., shared hidden state across steps, cross-step memory, “algorithmic” unrolling with supervision on intermediate states) turn iterations into scalable serial compute?
- Do alternative samplers/schedules (e.g., deterministic DDIM, higher-order solvers, variance-preserving vs variance-exploding noise, nonuniform step allocations) materially affect the seriality gap?
- Theory assumptions and scope
- The main theoretical claim relies on determinism, full observability in O(1) frames, and exact/near-exact score matching. How do the conclusions change under partial observability, sensor noise, multi-modality, or stochastic dynamics?
- The result is one-way (a limitation, not a characterization). Under what precise conditions can denoising steps provably add serial compute (e.g., with non-score-matching objectives or cross-step state)?
- The argument is framed in NCSN but claimed to extend to other formalisms. Provide formal proofs or counterexamples for rectified flows, consistency models, and flow matching with nontrivial couplings.
- Measuring “serial computation” directly
- Can we empirically quantify effective serial depth across denoising steps and backbone layers (e.g., via probing, intervention, mechanistic analysis) to validate that iterations do not accumulate task-relevant state?
- Is there evidence of early commitment or plan erosion specific to this benchmark (e.g., measuring when collision outcomes become fixed during denoising)?
- Compute accounting and fairness
- The paper asserts “comparable total compute” across settings but does not report FLOPs, latency, or memory for each variant. Provide controlled compute/latency-matched comparisons (bidirectional vs blockwise vs AR; depth vs width).
- Quantify the wall-clock and energy trade-offs for serializing inference versus deepening backbones, to inform practical deployment.
- Depth vs width scaling and optimization limits
- Depth helps more than width up to ~30 layers but shows diminishing returns, possibly due to optimization. Can improved training (normalization schemes, residual scaling, μParam, better LR schedules, regularization) push depth farther and close the gap without AR?
- What are the depth–data–compute scaling laws for serial-dependent tasks, and where are the breakpoints?
- VAE compression and temporal aliasing
- The Wan2.1 VAE downsamples 8× spatially and 4× temporally; each latent frame spans 4 rendered frames. Does temporal quantization obscure fast collision events, and does reduced compression (or no VAE) mitigate the gap?
- Evaluation methodology and metrics
- Position extraction relies on color-threshold segmentation and assumes known identities; this may bias metrics. Can coordinate-supervised training, differentiable renderers, or learned keypoint extractors reduce measurement noise?
- Add invariant checks (e.g., energy/momentum conservation, ball-count consistency) and report error bars/confidence intervals to assess statistical significance and robustness.
- Study sensitivity to the local-consistency horizon k and report performance across multiple k values and beyond-k drift.
- Dataset diversity and robustness
- Explore scaling in number of balls n≫5, higher collision rates, grazing collisions, near-chaotic regimes, and out-of-distribution initial conditions.
- Test generalization to longer horizons than trained, and to variations in textures/backgrounds without changing dynamics.
- Alternatives to inference factorization
- Beyond AR/blockwise masks, can search/planning modules, differentiable simulators-in-the-loop, or constraint-based decoders (e.g., enforcing non-penetration, conservation laws) reduce the gap while preserving bidirectional context?
- Training objectives that encourage serial reasoning
- Investigate auxiliary losses for event prediction (collision timing/location), intermediate-state supervision, or curriculum learning on chain length to promote stepwise reasoning within the backbone.
- Evaluate whether supervising denoising steps to maintain state (e.g., cross-step consistency or memory retention) yields scalable serial compute.
- Benchmarking beyond balls
- Provide additional controlled testbeds with the same dependent-event property but different perceptual factors (occlusions, clutter, textures) to separate visual difficulty from serial dependency.
- Release standardized datasets with event-chain annotations and scoring scripts to facilitate comparable research on serial reasoning in video.
- Autoregression limits and error accumulation
- Although AR helps here, quantify how AR error accumulation scales with horizon and event density, and when AR becomes inferior without stronger state estimation or correction mechanisms.
- Stochastic extensions
- For processes with inherent randomness, define appropriate targets (distributions over futures) and metrics (calibrated likelihoods, coverage of collision outcomes) to test whether the seriality gap persists under uncertainty.
- Interpretability of failure modes
- Tunneling, identity swaps, and ball-count violations are documented qualitatively. Can causal interventions pinpoint which layers/steps cause these failures and whether specific architectural changes (e.g., geometry-aware attention) prevent them?
- Reproducibility and resources
- Clarify dataset sizes, exact hyperparameters, sampler settings, and released code/checkpoints to enable rigorous reproduction and ablation by the community.
Practical Applications
Overview
This paper identifies the “seriality gap” in video diffusion models: when tasks require resolving long chains of dependent events (e.g., successive collisions), standard bidirectional video diffusion degrades with horizon length, and adding more denoising steps does not fix it. Empirically, performance improves disproportionately when:
- Inference is made more serial (blockwise or fully autoregressive).
- Backbone depth is increased (depth helps more than width). Theoretically, for deterministic video prediction with full observability, denoising steps do not add scalable serial computation beyond what the backbone already computes. This has concrete implications for how to build, evaluate, and deploy video generators and any generative models used as surrogates for simulation or reasoning.
Below are practical applications, grouped by deployment horizon.
Immediate Applications
Use this list to guide near-term engineering, evaluation, procurement, and research practices.
- Seriality stress-testing for video models
- Sector: AI/Software (foundation model labs, model evaluation platforms); Academia.
- What to do: Integrate the paper’s hard-sphere dependent-event benchmarks (multi-ball vs. single-ball controls) into internal and public eval suites; report serial-scaling curves (error vs. horizon) and local-physics consistency metrics.
- Tools/workflows: Add a “dependent-event” test slab to existing model CI; log tunneling, object-count, and identity-consistency violations alongside FVD/IS.
- Assumptions/dependencies: Synthetic diagnostics correlate with (but don’t fully represent) natural video; requires minimal simulator integration.
- Switch to blockwise or autoregressive (AR) inference for long-horizon or interaction-heavy content
- Sector: Video generation platforms (product), VFX/animation, gaming tools.
- What to do: Offer “Temporal Factorization Presets” (bidirectional, Block-k, full AR) selectable by shot length/interaction density; use smaller blocks as dependencies grow.
- Tools/workflows: FlexAttention-style block-causal masks; sliding-window AR for streaming.
- Assumptions/dependencies: Higher latency and memory; gains are largest when dependencies align with time.
- Depth-first architecture tuning for video diffusion backbones
- Sector: AI/Software (model builders).
- What to do: Prefer depth increases over width (up to an optimization-stable point) for tasks with strong dependent-event structure; reallocate parameter budgets accordingly.
- Tools/workflows: Architecture sweeps with depth/width budgets; monitor local-physics metrics.
- Assumptions/dependencies: Deep models can be harder to optimize (training stabilization may be needed).
- Consistency watchdogs for generated video
- Sector: Media platforms, safety/review teams, compliance; Robotics simulation QA.
- What to do: Deploy automated detectors for tunneling, object-count, and identity violations in long generations; flag, reject, or route for AR regeneration.
- Tools/workflows: Lightweight color/shape heuristics, tracker-based ID consistency checks, frame differencing; post-processing gates in pipelines.
- Assumptions/dependencies: Requires stable tracking/segmentation for target objects.
- Robotics and autonomy: world-model selection and training
- Sector: Robotics, autonomous vehicles, industrial automation.
- What to do: When using learned video world models for planning/forecasting collisions/contacts, prioritize AR or blockwise inference; validate with local-consistency metrics instead of only aggregate visuals.
- Tools/workflows: Short-horizon AR rollouts chained with control/planning; hybrid pipelines where a fast symbolic/physics step handles contact.
- Assumptions/dependencies: Real-world scenes are stochastic and partially observed—AR helps but does not remove the need for uncertainty modeling.
- Streaming and long-form video generation
- Sector: Creative tools, live-content generators.
- What to do: Use sliding-window AR with cached keys/values for long clips; reduce block size when sequences contain many interactions.
- Tools/workflows: Windowed attention with causal masks; adaptive block-size schedulers.
- Assumptions/dependencies: Throughput constraints; careful KV-cache management.
- Scientific surrogates: cautious use of diffusion for simulation replacement
- Sector: Energy, climate, materials, fluids; R&D.
- What to do: For surrogate tasks with long dependency chains (e.g., contact-rich or cascading dynamics), prefer AR/hybrid methods; require local-consistency checks.
- Tools/workflows: Simulator-in-the-loop validation; blockwise rollout with state extraction checkpoints.
- Assumptions/dependencies: Determinism/full observability in the paper does not fully match many scientific systems; still, the serial-compute lesson applies.
- Finance and other sequential forecasting: factorization guidance
- Sector: Finance, logistics, demand/supply forecasting.
- What to do: When using diffusion for sequence forecasting, test blockwise/AR variants and report dependency-length scaling; avoid relying solely on more denoising steps.
- Tools/workflows: Replace joint denoising with stepwise factorization where feasible; compare to AR baselines.
- Assumptions/dependencies: Extension from video to generic sequences requires domain adaptation and careful conditioning design.
- Procurement and policy checklists for “world-simulator” claims
- Sector: Public sector, enterprises buying generative models.
- What to do: Require seriality stress-tests, factorization controls (AR/blockwise modes), and documentation of serial-scaling performance before accepting “world-model/simulator” claims.
- Tools/workflows: Add seriality KPIs to RFPs and model cards.
- Assumptions/dependencies: Availability of standardized tests; evolving norms.
- Education and training modules
- Sector: Academia, corporate training.
- What to do: Use the hard-sphere task to teach serial vs. parallel compute, depth vs. width tradeoffs, and inference factorization; design labs where students toggle block sizes and observe error scaling.
- Tools/workflows: Jupyter-based simulators; open-source notebooks.
- Assumptions/dependencies: Minimal computing resources; availability of dataset code.
Long-Term Applications
These require further research, scaling, or development of new methods and standards.
- New iterative generative objectives that “carry computation” across steps
- Sector: AI research, foundation model labs.
- What to build: Non-score-matching or augmented objectives where intermediate states persist and accumulate reasoning/simulation state across iterations.
- Potential products: “Iterative Reasoning Diffusion/Flows” libraries; stateful denoisers with learned memory.
- Assumptions/dependencies: New training curricula; theoretical grounding and stability; evaluation protocols for carried state.
- Task-aligned inference factorization and causal planners
- Sector: AI dev tools, robotics, scientific ML.
- What to build: Learners that infer dependency graphs and choose matching factorization (temporal blocks, spatial segments, object-wise or event-wise ordering).
- Potential products: “Factorization Schedulers” that auto-select block sizes/order given a scene.
- Assumptions/dependencies: Reliable structure discovery; overhead must not erase gains.
- Hybrid simulators + generative models for contact-rich dynamics
- Sector: Robotics, VFX, AR/VR, engineering design.
- What to build: Pipelines where differentiable/symbolic simulators handle event chains while generative models handle appearance/stochasticity; handover at detected event boundaries.
- Potential products: Plugins for Unreal/Blender/ROS; “SimFusion” toolkits.
- Assumptions/dependencies: Differentiable interfaces; latency constraints; IP and licensing for engines.
- Adaptive serial compute orchestration at inference time
- Sector: Inference platforms, hardware co-design.
- What to build: Runtimes that allocate depth vs. time serial steps dynamically (e.g., shrink blocks when collision likelihood rises); hardware primitives for fast causal attention and deep pipelines.
- Potential products: Schedulers in inference servers; accelerator kernels for block-causal video transformers.
- Assumptions/dependencies: Profilers to detect dependency density; QoS constraints.
- Cross-domain seriality benchmark suites and standards
- Sector: Academia, standards bodies, industry consortia.
- What to build: Suites spanning hard-sphere, mazes, visual puzzles, manipulation—each with labeled dependency lengths and local-consistency metrics; standardized reports for “serial scaling”.
- Potential products: “SerialityScore” and “LocalConsistencyScore” analogous to VBench/FVD.
- Assumptions/dependencies: Community adoption; dataset maintenance.
- Regulatory guidance and model-card disclosures for serial reasoning
- Sector: Policy/regulators, certification bodies.
- What to build: Reporting standards on dependency-chain performance, factorization modes, and operational envelopes; require stress-test evidence for safety-critical deployments.
- Potential products: Seriality sections in model cards; certification checklists for autonomy and medical support tools.
- Assumptions/dependencies: Stakeholder consensus; sector-specific risk frameworks.
- Continuity-assured creative tools
- Sector: Media/VFX, game engines.
- What to build: Editors that guarantee scene continuity across long shots by defaulting to AR in interaction-heavy segments and locking object identities and counts.
- Potential products: “Continuity Mode” with hard constraints (identity, count, non-penetration) and AR regeneration when violated.
- Assumptions/dependencies: Usable constraint solvers; acceptable performance.
- Curriculum learning for serial dependencies
- Sector: AI research and training.
- What to build: Training regimes that progressively increase dependent-event chain length; adjustable factorization during training to match target workloads.
- Potential products: Curriculum schedulers; datasets with controllable serial complexity.
- Assumptions/dependencies: Data generation at scale; avoiding catastrophic forgetting.
- Extensions to multimodal and non-visual sequences
- Sector: Audio/music generation, multimodal agents, forecasting.
- What to build: Blockwise/AR factorization and seriality metrics for long-range audio structure, agent plans, and multimodal narratives.
- Potential products: “Seriality-aware” T2A (text-to-audio) and agent planners.
- Assumptions/dependencies: Domain-specific observability and metrics.
- Safety cases for high-stakes deployments
- Sector: Healthcare (surgical video assistance), autonomous driving.
- What to build: Safety cases that explicitly address the seriality gap, requiring AR/hybrid inference and local-consistency monitors before real-time decision support.
- Potential products: Regulatory-grade validation protocols; runtime monitors and fail-safes.
- Assumptions/dependencies: Strong detection and fallback strategies; sector approvals.
Notes on feasibility and scope:
- The paper’s strongest guarantees assume deterministic dynamics and full observability within a small number of frames; many real settings are stochastic and partially observed. Even so, the empirical pattern (AR/blockwise/depth helps; more denoising steps don’t) is likely to hold whenever dependencies grow with horizon and align at least partially with time.
- Autoregression is not a universal fix: when dependency structure is not time-aligned (e.g., puzzle-like reasoning), benefits must come from deeper backbones, task-aligned factorizations, planning, or new iterative objectives.
Glossary
- Autoregressive generation: A generation scheme that produces future frames sequentially, conditioning on previously generated frames. "Bidirectional diffusion degrades as collision chains lengthen, while autoregressive generation remains more accurate."
- Backbone: The core neural network (e.g., transformer/U-Net) that computes features or scores inside the diffusion process. "When predicting dependent events requires serial computation beyond the capacity of a fixed-depth backbone, the required computation must instead come from greater backbone depth or an inference factorization..."
- Bidirectional denoising: An inference paradigm where all frames are refined jointly across iterations rather than generated in causal order. "The dominant inference paradigm is bidirectional denoising: all frames are refined jointly by a bounded-depth backbone with access to both past and future frames."
- Bidirectional video diffusion: A diffusion approach that denoises all future frames jointly using information from both past and future contexts. "the performance of standard bidirectional video diffusion degrades as the causal chain lengthens"
- Billiard-ball computation: A theoretical model of computation using idealized elastic collisions of balls, known to encode complex (P-complete) computations. "the multi-ball task shares the elastic-collision primitive with classical -complete billiard-ball computation"
- Block-autoregressive: A diffusion inference strategy that generates videos in sequential temporal blocks rather than one frame at a time or all at once. "Autoregressive and block-autoregressive variants use the same base architecture but replace full temporal attention with FlexAttention~\citep{dong2024flex} block-causal masks over temporal latent frames."
- Block-causal masks: Attention masks that restrict information flow to past (and possibly current) blocks to enforce causal ordering in attention. "replace full temporal attention with FlexAttention~\citep{dong2024flex} block-causal masks over temporal latent frames."
- Blockwise generation (Block-k): Generating a fixed-size block of temporal latent frames at a time in a causal order. "We write Block- for generation in blocks of temporal latent frames;"
- Depth scaling: Increasing the number of layers in the backbone to add serial computational capacity. "Depth scaling is more effective than width scaling."
- DiT-style: A Diffusion Transformer architecture that applies transformer blocks to latent spatiotemporal tokens. "We train DiT-style~\citep{Peebles_2023_ICCV} video diffusion models adapted from Wan2.1~\citep{wan2025wanopenadvancedlargescale}"
- Denoising steps: The iterative refinement iterations used by diffusion models during sampling. "Increasing denoising steps provides little benefit and does not close the gap."
- Elastic collisions: Collisions that conserve both kinetic energy and momentum, with no energy lost to deformation or heat. "undergo perfectly elastic collisions with walls and with one another."
- EMA (Exponential Moving Average): A smoothed running average of model parameters used for more stable evaluation. "We maintain an exponential moving average (EMA) of the weights with decay $0.9999$"
- FlexAttention: A flexible attention mechanism enabling custom masking patterns such as block-causal masks. "replace full temporal attention with FlexAttention~\citep{dong2024flex} block-causal masks over temporal latent frames."
- Flow matching: A generative modeling view where learning targets the vector field (flow) that transports noise to data. "the flows in the corresponding flow-matching problem are just straight lines"
- Full observability: A property where a small, fixed number of observations uniquely determines the underlying system state. "This condition is known as full observability."
- Gaussian diffusion process: The forward noising process where Gaussian noise is gradually added to data over time. "We use the standard Gaussian diffusion process."
- Global error: A metric measuring average deviation from ground-truth positions across frames and entities. "Global error $\Delta x^{(\mathrm{GT)}$} measures the average Euclidean distance between predicted and ground-truth ball centers across all balls and evaluated frames."
- Hard-sphere dynamics: A simplified physical system of identical rigid balls moving frictionlessly and colliding elastically. "We use hard-sphere dynamics (Figure~\ref{fig:teaser}a): identical balls move frictionlessly in a square box and undergo perfectly elastic collisions with walls and with one another."
- Inference factorization: The choice of how to structure the generation process (e.g., bidirectional, blockwise, autoregressive) to allocate computation across time. "To separate inference factorization from architecture, we also vary backbone width and depth ."
- IoU (Intersection over Union): A shape-overlap metric used here to assess silhouette fidelity independent of position. "Visual quality (IoU) measures shape fidelity independently of position error."
- Local physical error (Δxk): A metric that checks short-horizon physical consistency by re-simulating from recent generated states. "Local error $\Delta x^{(k)$} measures local physical consistency."
- Noise rate function: The time-dependent function governing the rate at which noise is added in the forward diffusion. "The process is defined by a noise rate function "
- Noise-conditional score network (NCSN): A neural network that estimates the gradient of the log-density (score) at different noise levels. "We use the noise-conditional score-matching network (NCSN) formalism."
- P-complete: A class of problems believed to require inherently serial polynomial-time computation, not efficiently parallelizable. "At the serial end, -complete problems capture polynomial-time computations believed not to be efficiently parallelizable."
- Score function: The gradient of the log-probability density of the noised data, used to guide denoising. "Define the score function"
- Score matching: Training objective to learn the score function of the data distribution (or its conditional variants). "Under accurate score matching, denoising is not an independent source of scalable serial computation beyond the backbone."
- Seriality gap: The observed mismatch where tasks demand increasing serial computation but diffusion denoising does not supply scalable serial compute. "We identify this pattern as the seriality gap"
- Temporal dependency graph: The causal structure linking events across time that generation procedures should respect. "aligned with the temporal dependency graph"
- Temporal latent frames: Time-indexed representations in the model’s latent space used for video generation. "over temporal latent frames."
- Temporal self-attention: Attention operations along the temporal axis that scale quadratically with sequence length. "temporal self-attention scales as "
- Tunneling: A consistency failure where objects pass through others or teleport without valid intermediate states. "In tunneling, a ball passes through another object or disappears and reappears elsewhere without a physically valid intermediate trajectory."
- VAE latent space: The compressed representation space produced by a variational autoencoder in which diffusion operates. "Every model operates in the Wan2.1 VAE latent space, which downsamples videos by along each spatial axis and temporally."
Collections
Sign up for free to add this paper to one or more collections.


