Domain: Engineering — Computer Science
Target concept: Delete a node from a singly linked list

Video generation prompt: A concise 2D animation illustrates a set of numbered boxes arranged horizontally, representing 1, 2, 3, 4, 5, respectively. The boxes are connected by arrows in sequence, indicating a singly linked list. In this linked list, the node with the number 3 is removed from the list.

Evaluation guide:
Target concept: Deletion in a singly linked list is defined by *pointer redirection*, not node erasure. Minimum mechanistic assumptions: (i) nodes are immutable containers with a "next" field; (ii) links are unidirectional; (iii) deletion requires predecessor access; (iv) memory for deleted node becomes unreachable *only after* predecessor’s next pointer is updated. Phased storyline: (1) Stable initial state (1→2→3→4→5); (2) Target identification (node 3 highlighted); (3) Predecessor identification (node 2 emphasized); (4) Pointer detachment (2→3 arrow retracts); (5) Pointer reassignment (2→4 arrow extends); (6) Node invalidation (3 fades with strikethrough); (7) Stable final state (1→2→4→5). Visibility constraints: All nodes and arrows must remain fully in-frame; no zoom/pan; all text/numbers legible at 720p; causal transitions must be temporally separated and visually bracketed (e.g., detach completes before reassign begins).

Manual:
I. Basic Demonstration Information
Demonstration Title: Deletion of Node 3 from a Singly Linked List (1→2→3→4→5)
Subject: Engineering - Computer Science - Data Structures
Demonstration Purpose: To visually demonstrate the core algorithmic steps of deleting a middle node from a singly linked list, emphasizing pointer reassignment as the critical operation; to reinforce understanding of node connectivity, traversal dependency, and memory safety implications; and to train visual recognition of correct pointer-update causality.

II. Demonstration Carrier/Equipment
Core Carrier: 2D animated schematic — five identical rectangular nodes (white fill, black border, bold centered numbers), labeled "1", "2", "3", "4", "5", horizontally aligned with even spacing between them.
Auxiliary Elements: Thin, uniform unidirectional black arrows connecting consecutive nodes; transient visual cues: a brief red pulse on node 3 before deletion; a short blue highlight on node 2's outgoing arrow; a smoothly growing green arrow from node 2 to node 4; a gradual soft fade-out for node 3.

III. Demonstration Content Description
Layout: Nodes placed on a clean white background, centered horizontally; no labels other than the numbers; arrows strictly left-to-right, straight, non-overlapping.
State Control: Animation runs once, linearly, over a short total duration (no more than about 10 seconds); no user interaction; all motion is deterministic and replayable.
Comparison Baseline: Pre-deletion state shows the full chain 1→2→3→4→5; post-deletion state shows only 1→2→4→5 — identical node styling, same spacing, no extraneous elements.

IV. Observation of Core Phenomena
Pre-Deletion State: Five nodes visible in order; arrows connect 1→2, 2→3, 3→4, 4→5 — all arrows fully rendered and held steady for a clearly visible pause before anything changes.
Target Identification: Node "3" is distinctly pulsed with a red outline for a brief, clearly visible moment, with a short tooltip such as "target" appearing near it.
Pointer Update Sequence: (1) Node 2's outgoing arrow briefly highlights blue; (2) that arrow visibly detaches from node 3 (shrinking away); (3) a new arrow grows smoothly from node 2's right edge to node 4's left edge; (4) node 3 fades out (from fully visible to fully transparent) with a subtle strikethrough line, only after the new arrow has finished growing.
Post-Deletion State: The final frame shows a clean 1→2→4→5 chain; no residual arrow to or from node 3; node 3 fully invisible; all remaining arrows intact and correctly oriented.

V. Summary of Key Knowledge Points and Principles
Core Concept Definition: In a singly linked list, deleting an internal node requires updating the "next" pointer of its predecessor to bypass the target node — the target node itself then becomes unreachable and eligible for garbage collection.
Critical Causal Logic: Pointer reassignment must precede node removal to avoid dangling references. The animation enforces this: the 2→4 link is completed before node 3 fades.
Why Not Just Erase?: Visualizing erasure alone (without a pointer update) would depict a dangling pointer — a critical bug. The animation makes this error impossible to miss.
Further Knowledge: This operation is O(1) given predecessor access, but O(n) if traversal from head is required — the animation assumes predecessor (node 2) is already located.

Prompt Grounding rubric:
level_1: No linked-list scene is shown at all: there is no horizontal row of numbered boxes 1–5, no connecting arrows, no box labeled 3, and no deletion action of any kind: the clip shows something unrelated instead (e.g. plain text, an unrelated diagram, or abstract shapes).
level_2: Some pieces of the list appear (e.g. only 3–4 boxes, or arrows without all boxes), but key parts are wrong or missing: the boxes are not lined up horizontally, the numbers are not 1 through 5 in order, no box is clearly labeled 3, and there is no visible sign of a node being removed or of an arrow being reconnected.
level_3: Five boxes labeled 1–5 appear in a horizontal row with arrows running 1→2→3→4→5, but at least one flaw remains: the boxes are not styled consistently, one arrow's direction is unclear or reversed, node 3 is removed without ever being visibly marked/highlighted first, or the reconnection from 2 to 4 is only implied by the final state rather than actually shown happening.
level_4: Five evenly styled boxes labeled 1 through 5 sit in a left-to-right row connected by one-directional arrows; node 3 is clearly marked (e.g. an outline or color change) before it is removed; the arrow update from pointing at 3 to pointing at 4 is animated smoothly and unambiguously; only one small extra touch is missing, such as no fade-out on node 3 or no separate "head" label on the first box.
level_5: Every element matches the setup exactly: five evenly spaced rectangular boxes labeled 1, 2, 3, 4, 5 in order; clean one-directional arrows linking each consecutive pair; node 3 is visibly marked as the deletion target before anything else changes; the update plays out as separate, visible steps: the 2→3 arrow is shown pointing at 3, then it detaches from 3, then a new arrow grows from 2 to 4, then node 3 fades away; the final frame shows 1→2→4→5 with no leftover trace of node 3 or its arrow.

Scientific and Causal Correctness rubric:
level_1: The result is logically wrong: node 3 still has an arrow pointing to or from it after the 'deletion', node 4 ends up pointing back to node 2, the first box's identity changes unexpectedly, or an incorrect link appears (e.g. 1 pointing straight to 4); the removal of node 3 shows no visible cause-and-effect connection to any pointer change.
level_2: A major logic error remains: node 3 is gone but node 2's arrow still points to where node 3 used to be (a dangling arrow), or node 4 is shown with no incoming arrow while node 5 sits disconnected, or the deletion skips straight to the end state with no intermediate pointer change shown at all.
level_3: The final list is correctly 1→2→4→5 and node 3 is gone, but the steps leading there are not quite faithful: the arrow from 2 jumps straight to 4 with no visible detach-then-reconnect, or node 3 disappears before the 2→4 arrow is established, reversing the correct cause-and-effect order (the pointer should be redirected before node 3 is treated as gone).
level_4: The sequence matches linked-list logic: node 3 is located before it is acted on, node 2's outgoing pointer is redirected to node 4 before node 3 is shown fading away, and the final list 1→2→4→5 has no broken links, no leftover connection to node 3, and no loop; only a small detail is missing, such as no visual cue that node 3 is no longer reachable, or no 'previous node' marker on node 2.
level_5: The full mechanism is faithfully shown: the traversal that finds node 3 is visible (e.g. the 1→2→3 arrows light up in sequence as if being followed); it is visually clear that node 2's pointer is redirected from node 3 to node 4 before node 3 is treated as removed; node 3 only fades away after the 2→4 arrow is fully drawn; the final list 1→2→4→5 is stable, has no cycle, and matches what a correct singly-linked-list deletion should produce; no arrow ever points backward or to itself.

Spatiotemporal Consistency rubric:
level_1: Severe spatiotemporal breakdown: the boxes suddenly jump to different positions mid-animation; arrows appear or vanish with no transition; node 3 disappears before any pointer motion is shown; playback is jerky with obvious freezes or dropped motion; the boxes end up stacked or overlapping instead of staying in a horizontal row.
level_2: Frequent inconsistencies: the arrow from 2 to 3 is still visible at the same time the new 2→4 arrow is drawn; node 3 fades out while still connected to an arrow; the 2→4 arrow appears before node 3 has been highlighted as the target; boxes change size unexpectedly; the background shifts or rotates for no reason.
level_3: Mostly continuous with minor breaks: one noticeable stutter occurs while the 2→3 arrow detaches; node 3 and the new 2→4 arrow are both visible together briefly without a clear order between them; the 2→4 arrow snaps into its final position rather than visibly growing into place; the boxes stay in a horizontal row but spacing between them looks uneven.
level_4: Smooth, physically plausible motion throughout: transitions (highlighting, detaching, extending, fading) ease in and out rather than jumping instantly; each node highlight and arrow change lasts long enough to be clearly seen; the boxes stay fixed in place; arrows keep a consistent thickness and direction; nothing is drawn in the wrong front-to-back order, apart from one small imperfection, such as node 3's fade finishing a bit too quickly or one arrow's endpoint settling with a barely perceptible wobble as it finishes extending.
level_5: Flawless spatiotemporal coherence: no dropped frames or stutters anywhere; the stages (locating node 3, highlighting it, detaching the 2→3 arrow, extending the 2→4 arrow, fading node 3) each play out fully and are clearly separated in time, with every stage visibly finishing before the next begins; the boxes show no perceptible drift in position from start to end; arrows are drawn with consistent curvature and angle; node 3's fade looks like a smooth dissolve rather than an abrupt cut; arrows are always drawn on top of the boxes and highlights on top of arrows; at every moment it is visually unambiguous which change is happening and in what order.