Domain: Engineering — Computer Science
Target concept: Quick Sort Principle Demonstration

Video generation prompt: Display a simple horizontal numbered bar array on a clean white background (e.g., [3, 4, 1, 2]). Animate the step-by-step process of the Quick Sort algorithm sorting the array in ascending order.

Evaluation guide:
(i) Target concept: Visual demonstration of Quick Sort as a deterministic, recursive partitioning process.
Minimum mechanism: Bars must represent sortable values via height and label; pivot selection must trigger spatial reordering based on value comparison; partitioning must produce two disjoint, value-ordered subsets; recursion must operate independently on subsets without cross-contamination.
(ii)Storyline: Frame 0–1: Initial state: [3,4,1,2] bars horizontally aligned, labeled, on white background.
Frame 2–3: Pivot 3 highlighted; bars 1 and 2 shift left, bar 4 shifts right, forming [1,2] | [3] | [4] with visible separation.
Frame 4–5: Pivot 1 highlighted in left group; no further partition needed (single element).
Frame 6–7: Pivot 2 highlighted; confirmed ordered.
Frame 8–9: Pivot 4 highlighted; confirmed ordered.
Frame 10: Final stabilized [1,2,3,4]: all labels legible, heights ascending, no active highlights or motion. Perspective: Fixed front-facing 2D orthographic view; all elements fully visible; no occlusion; no camera movement or zoom.

Manual:
Experimental Procedure
1. Display initial horizontal bar array [3,4,1,2] on clean white background; each bar labeled with its value.
2. Highlight first pivot (e.g., 3), then partition: move bars ≤3 leftward, bars ≥3 rightward, preserving relative order within groups.
3. Recursively apply pivot+partition to left subarray [1,2] and right subarray [4].
4. Final state shows fully sorted ascending array [1,2,3,4].
Observation of Experimental Phenomena
- Bars change horizontal position only via discrete swaps or grouped shifts; no scaling or rotation.
- Pivot is visually distinct (e.g., red border) each time selected.
- Left/right partitions form clear spatial groups separated by gap or bracket.
- Final bar heights and labels increase left-to-right in strict ascending order.
Summary of Experimental Principles
Quick Sort is a divide-and-conquer algorithm that selects a pivot, partitions the array so elements ≤ pivot are on the left and ≥ pivot on the right, then recursively sorts subarrays.

Prompt Grounding rubric:
level_1: No numbered bar array appears at all; the bars aren't laid out in a single horizontal row; the background isn't a plain white; there's no animated change of any kind in the clip.
level_2: A static row of bars sits on a white background, but the bars are unlabeled or the numbers are unreadable; the starting values don't read 3, 4, 1, 2 in that left-to-right order; nothing in the clip ever moves or changes.
level_3: A horizontal row of bars labeled 3, 4, 1, 2 (in that left-to-right starting order) sits on a clean white background; the numbers on each bar are clearly legible; at least one step of animated movement occurs somewhere in the clip.
level_4: Everything required for score 3 holds, and in addition every bar keeps a consistent size and every label stays legible and correctly placed on its bar throughout the animation; the background and camera framing never change (no crop, no added or removed bars, no camera movement); some form of visual highlight (e.g., a color or border change) accompanies at least one of the moving bars.
level_5: Everything required for score 4 holds, and in addition the bars stay evenly spaced and identically sized from the first frame to the last, the labels stay bold and centered on their bars through every movement, the animation runs long enough to show more than one distinct highlighted moment (not a single instant cut to a final layout), and no bar, label, or highlight is ever blocked from view, duplicated, or dropped.

Scientific and Causal Correctness rubric:
level_1: Bars change size or position with no visible connection to any sorting logic; the numbers don't match what the bar heights would suggest; the array doesn't end up in ascending order; nothing distinguishes a pivot or a partition at any point.
level_2: Bars rearrange in a way that looks arbitrary (e.g., a random shuffle or a bubble-sort-style adjacent swap) rather than a pivot-based split; the numbers shown don't line up with the bar heights or positions; the final array isn't sorted, or it's sorted in the wrong direction; nothing on screen distinguishes the pivot from the left or right partition.
level_3: Bar height tracks the labeled value (the bar labeled 4 is the tallest, etc.); a pivot is visually marked as different (e.g., a different color or outline) at least once; the array splits into a left and right group, but the grouping is inconsistent between steps or breaks quicksort's rule at some point (e.g., a value greater than the pivot ends up in the left group).
level_4: Building on the 3-point bar, bar height is consistently proportional to value throughout; the pivot is marked the same way every time it's selected; the partitioning is correct in every step shown (every bar in the left group is at most the pivot's value and every bar in the right group is at least the pivot's value), with at most one place where a boundary or comparison looks off.
level_5: Building on the 4-point bar, bar height stays strictly proportional to value in every frame; the pivot marking looks identical every time it appears and always belongs to the subarray currently being processed; every partition step fully satisfies the left-less-than-or-equal-to-pivot-less-than-or-equal-to-right rule with no exceptions; the recursive breakdown covers every subarray with none skipped or merged early; the array ends the clip as 1, 2, 3, 4 with heights and labels in matching ascending order.

Spatiotemporal Consistency rubric:
level_1: A bar snaps from one spot to another with no visible motion between; a bar appears or disappears with no transition; the white background flickers or changes color/texture; several unrelated bars seem to move at once with nothing tying their timing together.
level_2: A bar's movement includes a visible jump, warp, or stretch rather than a clean slide; the pivot's highlight switches on or off instantly with no fade or transition; a shaded grouping region jumps to a new size instead of sliding or expanding; the background's lighting changes partway through the clip.
level_3: Every bar movement is a smooth slide with no rotation, stretching, or distortion; the pivot highlight fades in and stays visible for as long as that bar is the pivot; any shaded grouping region grows or shrinks smoothly rather than jumping; the background stays a uniform white with steady lighting; no bar is ever duplicated or deleted mid-animation.
level_4: Building on the 3-point bar, every bar's motion looks continuous and physically reasonable for a 2D animation; swaps happen as a coordinated left-right slide at a consistent pace; the pivot highlight transitions smoothly (fade or pulsing border) rather than snapping on and off; any grouping region stays aligned with the bars it represents as they move; the white background shows no visible texture, gradient, or shadow anywhere.
level_5: Building on the 4-point bar, there's no visible stutter or sudden jump in any bar's motion from one frame to the next; every bar keeps the same shape, spacing, and orientation throughout the clip; the pivot highlight keeps the same color and size every time it appears; any grouping region resizes and repositions only in step with the bars it tracks, with no lag or overshoot; the background stays a flat, featureless white in every frame.