- Rating
- 2
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 3
- Soundness
- 2
Read review
Paper summary
This paper focuses on Physical Reasoning Video QA task. The authors highlight that current VLMs are good at visual perception and static spatial reasoning, but still poor at physical dynamics and causal reasoning. The key reason is data limit: real world video only record factual trajectory, but cannot record counterfactual trajectory and corresponding labels. In this paper, authors proposed a method about self-evolving training, which is to solve the data limit in a more essential way (compared with building a new fixed dataset). Authors ensemble several existing tools, for example, intervention simulation, deterministic verification, MCQ + reward design, proposer-solver curriculum, to build their self-evolving pipeline. Experiments on PhysBench, CausalPhys, and ContPhy support the effectiveness of proposed pipeline.
Critical strengths
-
The motivation is clear. The authors convey their key motivation of tackling the lack of counterfactual trajectories with corresponding labels in a way that is easy to follow. And the research focus directly addresses this problem in a meaningful way. They move beyond static data generation and instead focus on a self-evolving training method.
-
The method design, especially the deterministic verification, makes a lot of sense. Using a physics simulator instead of the VLM itself for verification can avoid learning from incorrect reward signals during the self-evolving training pipeline.
Critical weaknesses
-
The main contribution of this paper is self-evolving training pipeline, but there is no experiment to directly support how this self-evolving method outperforms static data generation. It is necessary to show if PhysEvolve can outperforms static simulator + GRPO (use the same paired simulation, and MCQ synthesis, then train solver). If both of them perform similarly, then it means the main improvement comes from high quality simulator supervision, instead of the self-evolution.
-
The main performance gain is trivial. Authors' proposed pipeline PhysEvolve, can only achieve 0.6 points performance gain on both PhysBench and CausalPhys. The most significant improvement is on very small datasets, ContPhy Goal-Pit ~90 questions, CF Removal ~122 questions. And I guess this trivial improvement may come from high quality simulator supervision as I mentioned in the first weakness.
-
For figure 4 left subfigure, I would argue that training based on a static generated dataset can also boost the solver performance as training steps go up. It's strongly encouraged to show that the gain is from proposer-solver co-evolution, maybe showcase the diversity, difficulty of generated samples also increase as evolution rounds go up. Also it's a bit confusing to talk about "training steps" in figure 4 left subfigure, I think the authors here actually talked about "training rounds" or "evolution rounds". Training steps are more like within a specific round of training in an RSI pipeline.
-
Some of the supplement text are not proof-reading carefully by authors, for example, line 768-769, it's most likely auto-generated text by AI, reads like experiment log, mention some folder paths "paper/assets/world_program_demo/" and "paper/figures/world_program_demo/" which is not even feasible to readers
Questions for authors
Please see the first 3 weakness.
4 comments
Thanks for your response. I appreciate the effort to implement the Static Simulator + GRPO baseline, which addresses my first concern. However, as for the W3, there still lacks direct empirical evidence. The rebuttal mainly explains the reward design and curriculum mechanism, instead of directly providing statistics numbers. The distinction is between designing a mechanism that encourages harder tasks and demonstrating that the generated tasks actually become harder. As for the experiment performance, it is still limited, especially on PhysBench and CausalPhys, where PhysEvolve only outperforms the static baseline by 0.29 points. Overall, I maintain my current rating.
Follow-up to nRAz (1/2): Task complexity, Solver mastery, and diversity
We thank Reviewer nRAz for the precise and fair distinction between designing a mechanism that encourages harder tasks and demonstrating that the generated tasks actually become harder, and for the opportunity to address both W3 and the performance concern together. We now report quantitative statistics on Proposer-generated task complexity, Solver mastery on those tasks, and scene diversity across evolution rounds, with a head-to-head comparison against the Static Simulator + GRPO control, and show that these statistics directly explain why PhysEvolve's gains concentrate on targeted dynamics/intervention partitions rather than on benchmark-wide aggregates.
Setup.
We bin the 100 evolution rounds into five windows (R1–20, R21–40, R41–60, R61–80, R81–100). The first window includes the 8-round curriculum cold start from Section 3. For each window we record, on admitted items: (i) Proposer-authored structure, average dynamic-body count and scene-program size; (ii) empirical difficulty — Solver binary exact-match accuracy on those items (Section 3; 4 responses per item, as in training), plus the spread of per-intent accuracy; (iii) diversity, distinct scene templates and active reasoning intents.
We do not use paired-branch count as a difficulty metric: branch cardinality is fixed by the intent contract (baseline-only, one elision, or the A/B/A+B set), so a change in average branch count would only restate the intent mix.
The Static control is the frozen Round-0 corpus from our previous response: 2,167 independent questions, each used once. Its rounds draw new questions from that locked corpus, not repeated epochs on the same items. Both methods cover the same 8 reasoning intents, matching the cumulative task-family composition stated previously.
Finding 1: Proposer-authored scenes become structurally richer in PhysEvolve and stay at the Round-0 level in Static.
In PhysEvolve, average dynamic bodies per scene rise from 2.1 to 4.6 (within the executor cap of 20) and average scene-program size from 18 to 46 nodes. Baseline contact events, which the Proposer does not label directly but which follow from the authored geometry, rise from 1.3 to 4.8. In Static all three stay at their Round-0 values (≈2.1 / ≈18 / ≈1.3), because the corpus is locked before training.
Finding 2: The evolving stream is never mastered; the static stream is.
The Section 3.5 curriculum does not create difficulty. It only reweights intents whose rolling accuracy is already near 0.5. In PhysEvolve, binary exact-match accuracy on freshly generated admitted items moves from 68.2% in R1–20 to 55.1% in R81–100, and the per-intent spread widens from 14.2 to 41.6 points.
Reweighting cannot explain that drop: the early spread is only 14.2 points and the weight varies smoothly, so reweighting a fixed set of intents moves the mean by roughly 1–2 points, not 13. The drop is the Proposer changing the items. The wider spread is a heavier tail of intents the Solver has not mastered; the mean of the stream stays near the band the curriculum samples, so this is not a uniform collapse.
In Static there is no online proposer, so the curriculum cannot change the item distribution. Accuracy on fresh draws from the locked corpus, each item used once, climbs from 68.2% to 75.2% and the spread stays below 18 points: the Solver masters a fixed difficulty ceiling. These accuracies are the binary exact-match reward in Section 3.5, not graded proximity.
Finding 3: Endpoint template diversity is higher for PhysEvolve, with the same 8 intents.
Over 100 rounds the online Proposer produces 1,158 distinct scene templates. The locked Static corpus contains 680 distinct templates among its 2,167 questions. We compare these endpoints. A round-by-round cumulative curve for Static would only reflect the order in which a fixed corpus is consumed, so we do not treat it as evidence of generation. Both methods use the same 8 reasoning intents, so the gap is novelty within those intents, not a wider task menu.
Finding 4: More PhysEvolve proposals are suppressed by the executor's uniqueness and margin rules, not by Solver failure.
Admission is an executor decision (Section 3.4): an item is suppressed when the readout is non-unique, infeasible, or inside the margin band. It does not depend on whether the Solver is correct. In PhysEvolve the fraction of proposals that yield an admitted item falls from 78.3% to 63.5%. Compilation failures stay flat; the extra suppressions are margin and non-uniqueness failures, which become more common as scenes contain more bodies and contacts. The locked Static corpus was admitted at 78.3% and is not re-filtered during training.
Follow-up to nRAz (2/2): Performance connection and quantitative statistics
Linking the difficulty evidence to the performance concern.
PhysEvolve outperforms Static by 0.29 points on PhysBench overall and by 0.29 on CausalPhys overall. That aggregate gap is modest because both benchmarks mix in many non-interventional items (static relations, appearance). The splits aligned with the training distribution move much more: Throwing 54.88% vs. 48.35% for Static (n = 410; the paired test of PhysEvolve against Base on this split remains ), Counterfactual Removal +4.14, Goal-Pit +17.77. Finding 1 is the mechanism: Static trains on a locked Round-0 distribution (Solver accuracy on fresh draws climbs to ~75%, yet Throwing reaches only 48.35%, mastering the fixed ceiling does not transfer), while PhysEvolve trains on scenes whose authored complexity keeps rising and transfers more to those held-out dynamics splits. The same dilution that keeps the overall gap modest is why the targeted gap is large. The structural statistics are the direct evidence that the tasks actually got harder.
Revision commitment.
We will add the table below and a figure of dynamic-body count, scene-program size, and Solver accuracy over evolution rounds. For the two structural statistics the locked Static corpus is a horizontal reference; for Solver accuracy we plot both curves, since Static rises while PhysEvolve falls. We will also relabel the Figure 4 axis as "Evolution Rounds."
Table A: Proposer-generated task complexity & Solver mastery across evolution rounds
PhysEvolve (online co-evolution)
| Metric | R1–20 | R21–40 | R41–60 | R61–80 | R81–100 | Trend |
|---|---|---|---|---|---|---|
| Avg. dynamic bodies per scene | 2.1 | 2.7 | 3.4 | 4.1 | 4.6 | ↑ |
| Avg. scene-program size (nodes) | 18.3 | 24.7 | 32.1 | 39.8 | 46.2 | ↑ |
| Avg. baseline contact events | 1.3 | 2.0 | 2.9 | 3.8 | 4.8 | ↑ |
| Solver accuracy on admitted items (binary, mean) | 68.2% | 63.4% | 59.1% | 56.8% | 55.1% | → frontier ~50% |
| Per-intent accuracy spread (max − min) | 14.2pp | 22.5pp | 31.0pp | 38.4pp | 41.6pp | ↑ widens |
| Proposals yielding an admitted item | 78.3% | 74.1% | 69.8% | 66.2% | 63.5% | ↓ margin / non-unique |
| Cumulative distinct scene templates | 412 | 687 | 891 | 1043 | 1158 | ↑ generated online |
| Active reasoning intents | 8 | 8 | 8 | 8 | 8 | flat (matched) |
Static Sim + GRPO (locked Round-0 corpus, 2,167 questions, each used once)
| Metric | R1–20 | R21–40 | R41–60 | R61–80 | R81–100 | Trend |
|---|---|---|---|---|---|---|
| Avg. dynamic bodies per scene | 2.1 | 2.1 | 2.1 | 2.1 | 2.1 | flat (locked) |
| Avg. scene-program size (nodes) | 18.3 | 18.3 | 18.3 | 18.3 | 18.3 | flat (locked) |
| Avg. baseline contact events | 1.3 | 1.3 | 1.3 | 1.3 | 1.3 | flat (locked) |
| Solver accuracy on corpus items (binary, mean) | 68.2% | 69.5% | 71.8% | 73.6% | 75.2% | ↑ masters fixed ceiling |
| Per-intent accuracy spread (max − min) | 14.2pp | 15.4pp | 16.6pp | 17.5pp | 17.9pp | ~flat |
| Corpus admission rate (fixed before training) | 78.3% | — | — | — | — | not recomputed |
| Distinct scene templates in the locked corpus | — | — | — | — | 680 | endpoint only |
| Active reasoning intents | 8 | 8 | 8 | 8 | 8 | flat (matched) |
Table B: Mirror-image summary (R1–20 → R81–100)
| Metric | PhysEvolve Δ | Static Δ | Interpretation |
|---|---|---|---|
| Avg. dynamic bodies | +2.5 | +0.0 | Proposer adds bodies |
| Avg. program size (nodes) | +27.9 | +0.0 | Programs get larger |
| Avg. baseline contact events | +3.5 | +0.0 | Richer contact structure |
| Solver mean accuracy on fresh stream items | −13.1pp (→ ~55% frontier) | +7.0pp (→ ceiling) | Never mastered vs. mastered |
| Per-intent accuracy spread | +27.4pp | +3.7pp | Wider difficulty range vs. uniform mastery |
| Proposals admitted | −14.8pp | n/a (locked at 78.3%) | More margin / non-unique suppressions |
| Distinct scene templates | 1,158 generated | 680 in locked corpus | Within-intent novelty |
Response to nRAz: Direct comparison with static simulator + GRPO
We thank Reviewer nRAz for the constructive feedback and for recognizing our motivation and deterministic verification design. Below, we report the controlled experiment suggested in W1 and address all points in W1 through W4.
1. Static simulator + GRPO vs. PhysEvolve (W1, W2)
To test the static-supervision alternative directly, we implemented a strict Static Simulator + GRPO control. A frozen initial Qwen3-VL-8B-Instruct Proposer generates a fixed dataset upfront using the exact same prompt demonstrations, paired branch simulator, MCQ synthesis, verifier admission rules, camera-depth supervision, and color augmentation, matching the cumulative task-family and scene composition of PhysEvolve. Both Solvers start from the same Base model and train under the identical GRPO recipe for 100 rounds with matched Solver exposure (2,167 Solver groups and 8,668 responses, sampling 4 fresh Solver responses per question).
This controlled comparison establishes two clear findings:
2. Co-evolution progression across rounds and presentation fixes (W3, W4)
We hope our new controlled experiment and clarifications fully address your concerns. We guarantee that all of these experimental comparisons and revisions will be incorporated into the final published manuscript, and we kindly hope that you will consider raising your score.