Domain: Engineering — Computer Science
Target concept: Depth-First Search (DFS) of a Graph Demonstration

Video generation prompt: Create a simple animated graph on a white background, consisting of 6 labeled nodes (A-F) connected by lines. Highlight the DFS process starting from node A: the starting node turns red, and DFS advances one unvisited neighbor at a time, going as deep as possible along a single branch before backtracking. A stack visualization is updated synchronously on the side to track the current path, and processed nodes gradually fade to gray upon completion.

Evaluation guide:
(i) Target concept: Visual demonstration of Depth-First Search traversal on an undirected graph using color-coded node states and a synchronized stack display.
Minimum mechanism: Graph structure (6 nodes A-F, fixed edges) must be fixed and explicitly represented; from the current red (active) node, DFS must move into exactly one unvisited neighbor at a time, never activating multiple neighbors of the same node simultaneously; when the active node has no unvisited neighbors left, traversal must backtrack to the previous node on the stack and try its next unvisited neighbor; color state transitions must be irreversible and mutually exclusive (no node simultaneously red and blue; no gray node reactivated).
(ii)Storyline: Frame 0–1: White background appears; static graph with labeled nodes A–F and connecting lines (e.g., A-B, A-C, B-D, C-E, C-F) is fully visible; stack box is empty and positioned fixed on the right. Frame 2–3: Node A turns red; stack updates to [A]. Frame 4–5: DFS moves into A's first unvisited neighbor, B, which turns blue then red as it becomes the new active node; stack updates to [A, B]. Frame 6–7: DFS moves into B's first unvisited neighbor, D, coloring it blue then red; stack updates to [A, B, D]. Frame 8–9: D has no unvisited neighbors, so it fades to gray and is popped from the stack, returning to [A, B]; DFS backtracks to B, but B also has no remaining unvisited neighbors, so B fades to gray and is popped, returning to [A]. Frame 10: DFS resumes from A, moving into its next unvisited neighbor, C; the process repeats (always exploring one node deeper before backtracking) until every node has turned red once, then faded to gray. Perspective: Fixed front-facing orthographic view; all elements fully in frame; no camera motion; no occlusion; all text and colors legible.

Manual:
Experimental Procedure
1. Render static white canvas with 6 labeled nodes (A–F) positioned in an open layout; draw undirected edges connecting them per a valid graph (e.g., A-B, A-C, B-D, C-E, C-F).
2. Begin animation: Node A turns solid red; push A onto the stack.
3. From the current red node, color its first unvisited neighbor blue, then red as it becomes the new active node (e.g., A -> B); push it onto the stack.
4. Repeat step 3 from the new active node, always moving one edge deeper into an unvisited neighbor (e.g., B -> D), pushing each newly active node onto the stack.
5. When the active node has no unvisited neighbors left, fade it to gray, pop it off the stack, and resume from the node now on top of the stack, trying its next unvisited neighbor.
6. Continue until every node has been activated once and faded to gray, and the stack is empty.
Observation of Experimental Phenomena
- Node A appears red first.
- At any moment, only one node is red (active); at most one neighbor of that node turns blue immediately before becoming the next active (red) node.
- The stack on the right grows by one node each time DFS moves deeper, and shrinks by one each time a node is fully processed and fades to gray (backtracking).
- Processed nodes fade continuously to neutral gray and remain static.
Summary of Experimental Principles
DFS explores as far as possible along a single branch before backtracking: from the active node it moves into one unvisited neighbor at a time rather than activating several neighbors at once; a stack tracks the current path from the start node and supports backtracking to the most recent node with unexplored neighbors when a dead end is reached.

Prompt Grounding rubric:
level_1: No graph appears; the 6 labeled nodes (A-F) or the connecting lines are missing; no stack panel is shown on the side; no node ever changes color from its initial state.
level_2: A static graph of 6 labeled nodes (A-F) with connecting lines appears on a white background, but nothing animates: node A never turns red, no node ever turns blue, no stack panel appears, and no node fades to gray.
level_3: The animated graph shows all 6 labeled nodes (A-F) and their connecting lines; node A turns red at the start; at least one other node turns blue then red at some point; a stack panel is present on the side; at least one node fades to gray, but not all six nodes ever get activated, or the stack panel stays static throughout.
level_4: All 6 labeled nodes (A-F) and their edges are present throughout; node A starts red; nodes visibly cycle through blue-then-red-then-gray as the animation proceeds; the stack panel's contents change more than once during the clip; every one of the 6 nodes eventually turns red at some point and later fades to gray, but one small setup flaw exists, e.g., a node label is misdrawn, or one edge is missing from the initial graph.
level_5: All 6 labeled nodes (A-F) are clearly labeled on a uniform white background, connected by clean, unbroken lines forming one fixed graph with no extra or missing edges; node A turns red in the opening frames; every other node visibly passes through blue, then red (when activated), then gray (when finished) at some point in the clip; the stack panel is present the entire time and its contents visibly change as nodes are added and removed; all six nodes end the clip faded to gray, and all elements stay fully visible and legible throughout.

Scientific and Causal Correctness rubric:
level_1: No causal relationship between the current active (red) node and which node changes next; colors appear on nodes with no edge to any active node; the stack panel shows content unrelated to the actual traversal; a node fades to gray without ever having been active.
level_2: Node A turns red, but the traversal never proceeds to a real neighbor of A (e.g., a node with no edge to A turns blue); or multiple neighbors of the same active node turn red/active at once instead of one at a time; the stack panel does not track the actual path being explored.
level_3: Node A turns red, and the traversal correctly moves into one of A's real neighbors, but at some point two neighbors of the same active node are both colored blue or both become active simultaneously (violating single-branch, one-at-a-time exploration); the stack panel roughly tracks the path but has one wrong entry or omission; backtracking (returning to an earlier node after a dead end) never visibly occurs even though the graph requires it.
level_4: The traversal always advances into exactly one unvisited neighbor of the currently active node, never multiple at once; the stack panel's entries grow by one each time DFS goes deeper and shrink by one each time it backtracks, matching the current path from the start node; a node fades to gray only once it has no remaining unvisited neighbors and control has moved back to an earlier node, but one deviation exists, e.g., a node is skipped and later revisited, or a fade-to-gray happens one step too early relative to the backtrack.
level_5: The traversal strictly follows single-branch DFS semantics: (1) only one node is red/active at any time; (2) each move activates exactly one unvisited neighbor of the currently active node, going as deep as the graph allows; (3) when the active node runs out of unvisited neighbors, it fades to gray and traversal resumes from the nearest earlier node on the path that still has an unvisited neighbor; (4) the stack panel's contents at every moment match the current path from the start node to the active node, growing on descent and shrinking on backtrack; (5) every node is activated exactly once and never re-colored after fading to gray.

Spatiotemporal Consistency rubric:
level_1: Nodes jump to different positions on screen between frames; edges appear or disappear abruptly without redrawing; the background flashes or changes color; the stack panel jumps to a new location or changes size abruptly; node labels vanish and reappear at random; a node's color fills in instantly with no visible transition.
level_2: Nodes stay in fixed positions, but the edges connecting them bend, stretch, or shrink unnaturally as the animation plays; the stack panel shifts position between frames; a node label rotates or changes size mid-animation; a color change happens as an instant flash rather than a gradual shift.
level_3: All 6 nodes stay in the same spot throughout; every edge keeps the same shape and length; the stack panel stays in the same general area on the right side; labels stay upright and readable; color changes fade in smoothly rather than snapping instantly, but one visible hiccup occurs, such as a brief flash where a node looks red and blue at once, or the stack panel briefly looks semi-transparent.
level_4: Nodes and edges keep the same position, size, and shape for the entire clip with no warping or drifting; the stack panel stays in the same place and does not resize; every color change (blue-to-red, red-to-gray) fades in smoothly and in the same direction with no node reverting to an earlier color; the panel's list of nodes updates smoothly without abrupt reflow, but one node's fade-to-gray visibly finishes noticeably later or earlier than the others in a way that looks inconsistent.
level_5: No node, edge, or label ever shifts, resizes, rotates, or warps for the entire clip; the stack panel keeps the same size and position throughout; every node's color change (to blue, to red, to gray) is clearly timed to line up with the corresponding update in the stack panel (a node turns red as it is added to the panel, fades to gray as it is removed); no node flickers, freezes, or shows an unexplained color simultaneously with another state.