Domain: Engineering — Computer Science
Target concept: Inserting a Node into a Singly Linked List

Video generation prompt: A concise 2D animation illustrates a set of numbered boxes arranged horizontally, representing the values 1, 2, 3, 4, 5, respectively. The boxes are connected sequentially by arrows, indicating a singly linked list. A node numbered 6 is inserted between the second and third nodes of the list, with the process of pointer changes during the insertion step-by-step demonstrated.

Evaluation guide:
Target concept: Singly linked list node insertion, a deterministic, pointer-based operation requiring exactly two next-field modifications (predecessor → new, new → successor) to maintain a linear, acyclic structure. Minimum mechanistic assumptions: (1) Nodes are memory blocks with a data field (numeric label) and a next pointer (arrow); (2) Arrows represent directed references, not physical connections; (3) Insertion location is defined by predecessor-successor adjacency, not index; (4) the safe insertion order sets the new node's own forward pointer before redirecting the predecessor, so the list is never missing a path to the successor at any intermediate moment. Expected phenomena storyline: Phase 1 (0–1.2s): Stable 1→2→3→4→5 list. Phase 2 (1.2–2.4s): Node 6 enters the gap between 2 and 3; node 6's arrow draws forward to node 3 first, giving the new node its own onward link while node 2 still points to node 3 as a fallback. Phase 3 (2.4–3.6s): Node 2's arrow then detaches from node 3 and reattaches to node 6, safely redirecting the predecessor only after node 6 already has a valid path to node 3. Phase 4 (3.6–4.8s): Static confirmation, full chain 1→2→6→3→4→5 visible, with node 3's outgoing arrow unchanged since start. Visibility constraints: All labels and arrows must be legible at 720p; no occlusion; arrows must terminate clearly at node centers; no text overlays or narration needed; causality must be self-evident from motion and topology.

Manual:
I. Basic Demonstration Information
Demonstration Title: Inserting a Node into a Singly Linked List (Node 6 inserted between nodes 2 and 3)
Subject: Engineering - Computer Science - Data Structures
Demonstration Purpose: To visually demonstrate the step-by-step pointer manipulation required to insert a new node into a singly linked list, reinforcing the algorithmic logic, memory reference semantics, and structural integrity constraints of singly linked lists.

II. Demonstration Carrier/Equipment
Core Carrier: 2D animated schematic — five identical light-blue rectangular nodes labeled "1", "2", "3", "4", "5" arranged horizontally with black unidirectional arrows (→) connecting them sequentially (1→2→3→4→5). A sixth node labeled "6", identical in style, enters from above.
Auxiliary Elements: Clean white background; sans-serif numeric labels (14pt, black); arrows rendered as thin black lines with filled arrowheads; no grid, no axes, no code snippets or memory addresses.

III. Demonstration Content Description
Layout: Nodes 1–5 fixed on horizontal axis, equally spaced (200px apart center-to-center). Initial gap between node 2 and node 3 is 200px. Node 6 enters from y=−100px, moving downward at constant speed to settle centered in the expanded 300px gap between nodes 2 and 3.
State Control: Animation proceeds in three discrete, non-overlapping phases, in the safe insertion order: (1) node 6's outgoing arrow draws to node 3 first, giving the new node a valid forward link while node 2 still points to node 3 as a fallback; (2) node 2's outgoing arrow then detaches from node 3 and reattaches to node 6, now that node 6 already points onward to node 3; (3) node 3's outgoing arrow remains unchanged throughout. Each phase lasts 1.2 seconds, with 0.3s static pause between phases.
Comparison Baseline: Pre-insertion state shows intact 1→2→3→4→5 chain; post-insertion state shows 1→2→6→3→4→5 chain — identical node values, same arrow directionality, no new cycles or breaks.

IV. Observation of Core Phenomena
Initial State: Five nodes in strict left-to-right order; arrows strictly unidirectional and sequential; no visual clutter.
Insertion Target: Node 6 enters *only* into the gap between node 2 and node 3 — confirmed by spatial positioning (centered x-coordinate between nodes 2 and 3) and temporal isolation (no other node moves).
Pointer Changes: Three and only three pointer updates occur, in the safe order: (a) node 6's arrow emerges and locks onto node 3 first, giving the new node a valid outgoing link; (b) node 2's arrow endpoint then migrates from node 3 to node 6, redirecting the predecessor only now that node 6 already leads to node 3; (c) node 3's arrow remains visually identical before/during/after — confirming its next field is *not* modified.
Structural Integrity: Final list remains linear, acyclic, and fully traversable: following the arrows yields sequence 1→2→6→3→4→5 — no skipped nodes, no repeats, no dead ends.

V. Summary of Key Knowledge Points and Principles
Core Concept Definition: Insertion into a singly linked list requires updating *exactly two* next pointers to preserve connectivity: the new node's next (node 6) and the predecessor's next (node 2). The successor's next (node 3) must remain unchanged to retain downstream links.
Algorithmic Principle: This operation is O(1) *given access to the predecessor node* — visualized by direct manipulation of node 2's pointer, bypassing traversal from head. Setting node 6's next before redirecting node 2's next is the standard safe order, since it guarantees the list is never missing a path to node 3, even for an instant.
Visual Feature Recognition Criteria: Correctness is verified by (i) spatial placement (6 between 2 and 3), (ii) temporal sequence (6→3 established before 2→6 is redirected), and (iii) invariant preservation (3's arrow unchanged). Any deviation violates the singly linked list abstraction.

Prompt Grounding rubric:
level_1: No horizontal chain of numbered boxes appears, no arrows link them, and node '6' is absent or never introduces an insertion; the clip shows something unrelated to a linked list (e.g., a tree, a grid, or plain text).
level_2: A row of boxes appears but the numbering skips or repeats a value (e.g., no box shows '3'), arrows are missing or point the wrong way, or node '6' is only shown sitting statically with no attempt to insert it between two existing boxes.
level_3: The initial chain shows five evenly spaced boxes labeled 1 through 5 in order with left-to-right arrows between them, and node '6' appears and is inserted somewhere, but not clearly between the boxes labeled '2' and '3' (e.g., it lands at the head or tail instead), or the pointer redirection needed to splice it in is never shown.
level_4: The initial chain (1→2→3→4→5) is shown correctly, node '6' is inserted specifically between the boxes labeled '2' and '3', and both new pointer connections are visibly drawn (an arrow reaching node '6' and an arrow from node '6' onward), while node '3's original arrows stay visually unchanged, but the two new arrow changes overlap in time or one of them fades in rather than being clearly redrawn.
level_5: The clip matches the prompt exactly: five uniform boxes labeled '1' through '5' sit in a row connected by clean rightward arrows (1→2, 2→3, 3→4, 4→5); box '6' visibly slides in from above or below into the gap between '2' and '3'; the new arrow from node '6' to node '3' is drawn first, then the arrow from node '2' is redirected away from '3' and onto node '6' second, and node '3's own outgoing arrow to '4' never changes; each of these two arrow changes is a distinct, legible, separately-timed redraw rather than a simultaneous swap.

Scientific and Causal Correctness rubric:
level_1: Pointers behave with no logical relationship to the list (e.g., node '2' points to node '5', node '6' points to itself), the insertion breaks the chain into something incoherent (e.g., 1→2→6→6→3), a box's number changes value mid-clip (e.g., '2' becomes '7'), or an arrow points backward, creating a two-way link or a loop.
level_2: The five-then-six-node chain stays intact, but a pointer is wired incorrectly: node '6' points to nothing instead of to node '3', node '2' skips over node '6' and still points straight to node '3', or node '3's own outgoing arrow gets redrawn when it should not change; or a box's printed number does not match the value it represents.
level_3: Node '6' is shown gaining its own outgoing arrow to node '3' and node '2's arrow is shown moving from node '3' to node '6', so the final chain reads 1→2→6→3→4→5 correctly, but the two changes happen in the same instant with no visible order between them, or node '6's new arrow is drawn as a curved or indirect path rather than a straight directional link; node '3's arrow is otherwise untouched.
level_4: The two pointer changes occur in the safe order: node '6's arrow to node '3' is drawn first, giving the new node a valid onward link while node '2' still points to node '3' as backup, and only afterward does node '2's arrow redirect from node '3' onto node '6'; this order means the list is never missing a path to node '3' at any point during the edit; node '3's arrow stays unchanged throughout; only a minor flaw remains, such as a brief moment where both node '2's old and new arrows are visible together.
level_5: The insertion makes the textbook-safe pointer order visually explicit: node '6's outgoing arrow to node '3' completes first, so the new node is fully wired into the list before it becomes reachable; node '2's arrow is redirected from node '3' to node '6' only afterward, at which point the predecessor link switches over without any moment where node '3' is unreachable from the front of the chain; the final chain 1→2→6→3→4→5 has no loop and no dead end, and node '3's arrow to node '4' never moves; every box's shape (rectangle = node) and every arrow (line = a single forward pointer) stays consistent with singly linked list semantics, with no reverse arrows or extra 'previous' links.

Spatiotemporal Consistency rubric:
level_1: Boxes jump to new positions with no motion in between, arrows snap into place instantly rather than being drawn, node '6' appears or disappears mid-clip with no entry animation, the final six-box chain is shown before the insertion steps play out, or the boxes stack up or overlap instead of staying in a single row.
level_2: The boxes stay roughly in a single row but their spacing changes unevenly between shots; an arrow's endpoint teleports from one box to another instead of visibly redrawing; node '6' simply appears in its final spot with no slide-in or fade-in motion; or node '2's arrow is shown reaching node '6' before node '6's own arrow to node '3' has appeared, breaking the intended order.
level_3: The boxes keep a stable left-to-right order and spacing; the arrow redraws use simple, visible motion rather than instant snaps; node '6' enters with a basic slide from above or below; but the timing feels uneven (for instance one arrow redraw takes noticeably longer than the other with no clear reason), and a box may briefly flicker or resize during a transition.
level_4: Node '6' slides in along a clear, continuous path into the gap between '2' and '3'; both arrow redraws (node '6' to node '3', then node '2' to node '6') play out smoothly with comparable timing and no box relocates or resizes unexpectedly; the gap between '2' and '3' visibly widens to make room for node '6' before it settles in; only a small flaw remains, such as slight wobble in an arrowhead as it attaches.
level_5: Every box stays aligned on a single row throughout, with the gap between '2' and '3' widening smoothly to fit node '6' before it settles in place; node '6' moves with a natural ease-in/ease-out motion rather than constant speed; the two arrow redraws are clearly separated in time and each completes with a clean, unambiguous endpoint on the target box; there is no stutter, no box briefly vanishing, and every label stays readable throughout the clip.