Domain: Engineering — Computer Science
Target concept: Demonstration of the Execution Process of Sequential Search Algorithm

Video generation prompt: A concise 2D animation illustrates an array of numbered boxes arranged horizontally (e.g., [5, 1, 2, 4, 3]), with a highlighted pointer moving from left to right to perform a sequential search for a target value (e.g., 4).

Evaluation guide:
Target concept: Sequential search, a deterministic, linear, index-ordered traversal algorithm that compares elements one-by-one until first match. Minimum mechanistic assumptions: (1) array is static and unsorted; (2) search proceeds strictly left-to-right by index; (3) termination occurs immediately upon equality detection; (4) no implicit memory or backtracking. Phased storyline: [Phase 1: Static setup. Array [5,1,2,4,3] and "Target: 4" banner displayed.] → [Phase 2: Initiation. Pointer appears at index 0 (5), pulses, compares "5==4? → false".] → [Phase 3: Iteration. Pointer advances to 1→2→4, each with identical compare-false feedback.] → [Phase 4: Termination. Pointer lands on 4, triggers synchronous green pulse + "4==4" confirmation + "FOUND" badge.] → [Phase 5: Completion. Animation holds final state for ≥0.5s. Visibility constraints: All numbers and pointer must be legible at native resolution; no occlusion; perspective is strict 2D front-facing orthographic view; no camera motion or zoom.

Manual:
I. Basic Demonstration Information
Demonstration Title: Sequential Search Algorithm Execution Process Demonstration
Subject: Engineering - Computer Science - Algorithms
Demonstration Purpose: To visually demonstrate the step-by-step execution of the sequential search algorithm on a fixed-size array, highlighting the left-to-right traversal pattern, element-by-element comparison, and termination upon first match; to reinforce understanding of linear time complexity and deterministic control flow.
II. Demonstration Carrier/Equipment
Core Carrier: 2D animated schematic — horizontal row of 5 uniformly sized, bordered, rectangular boxes containing integers [5, 1, 2, 4, 3]; a movable pointer (e.g., downward-pointing red triangle); persistent target indicator (e.g., banner "Target: 4").
Auxiliary Equipment: Clean white or light-gray background; sans-serif numeric labels (size ≥24pt, high contrast); frame rate ≥30fps; total duration ≤10s.
III. Demonstration Content Description
Layout: Array centered horizontally; pointer begins aligned with leftmost box (value 5); target banner placed above array.
State Control: Pointer advances strictly left-to-right, one box per step; dwell time per box = 0.6s; upon reaching value 4 (third box from right, index 3), pointer pauses 0.8s while matched box pulses green and displays "MATCH!"
Comparison Baseline: All boxes identical in size, spacing, fill (white), border (black, 2px), and font; only numeric content and pointer state vary.
IV. Observation of Core Phenomena
Pointer Motion Pattern: Smooth, discrete, sequential translation — no interpolation errors, no skipping, no reversal.
Visual Comparison Feedback: At each box, a transient visual cue (e.g., subtle glow + tooltip "X == 4?") appears synchronously with pointer landing.
Match Confirmation: Exclusive, unambiguous response only at value 4 — green pulse + bold "4" + "FOUND" badge; no secondary effects elsewhere.
Characteristic Stability: Array geometry, label legibility, and pointer shape remain invariant throughout; no flicker, scaling, or color bleed.
V. Summary of Key Knowledge Points and Principles
Core Concept Definition: Sequential search is a brute-force algorithm that checks each element of a list in order until the target is found or the list ends; worst-case time complexity is O(n), best-case O(1).
Algorithmic Logic Visualization: The animation directly maps abstract pseudocode (FOR i = 0 TO n−1 DO IF A[i] == target THEN RETURN i) to observable states — position ↔ index, pulse ↔ comparison, green highlight ↔ return condition.
Pedagogical Significance: Reinforces procedural thinking, state tracking, and the importance of termination conditions; contrasts with binary search by emphasizing lack of ordering assumptions.

Prompt Grounding rubric:
level_1: No horizontal array of numbered boxes appears; there is no moving pointer; no target value is shown anywhere in the frame; the video bears no visible resemblance to a sequential-search animation.
level_2: Some elements appear (for instance loose numbers or a static arrow), but the array is not laid out horizontally, the boxes are not uniform and clearly numbered, the pointer never moves, or the target value is missing or does not match the array (e.g., the target is stated as 7 while the array only contains 5, 1, 2, 4, 3).
level_3: The array [5, 1, 2, 4, 3] is shown as evenly spaced horizontal boxes and a pointer is present, but its motion is wrong in some way: it jumps over positions, moves right-to-left, or stops before ever reaching the box containing 4; the target label (e.g., 'Target: 4') is hard to read, oddly placed, or missing.
level_4: The array [5, 1, 2, 4, 3] is clearly labeled and horizontally arranged, the target value is displayed in a legible banner, and the pointer visits each box in order from left to right, but one non-essential flaw remains, such as the pointer's color blending into the background, inconsistent box borders, or no visible highlight when the pointer reaches the matching box.
level_5: The animation shows exactly five evenly spaced, uniformly styled boxes labeled 5, 1, 2, 4, 3 in a horizontal row; a clearly legible target banner (e.g., 'Search for: 4') stays fixed on screen; the pointer starts at the leftmost box and moves smoothly and in order to the right, coming to a visible, sustained stop with a distinct highlight (e.g., a green flash or bold outline) only on the box containing 4; all colors and text remain crisp and easy to read throughout.

Scientific and Causal Correctness rubric:
level_1: The pointer's position bears no relation to which comparisons are being made: for instance it appears on a random box, or the 'found' moment happens without the pointer ever having visited the earlier boxes in order, violating the basic logic of checking elements one at a time.
level_2: The pointer moves, but there is no visible sign that a comparison is happening at each box (no highlight, no equality symbol, no on-screen text); or the animation declares a match at the wrong box (e.g., at the box holding 2 instead of 4); or the stated target value changes partway through the animation.
level_3: The pointer moves left to right and pauses briefly at each box, with some visible feedback at each stop (e.g., a brief highlight), but there is no clear signal marking the moment of success (no 'FOUND' text, no distinct color change on the matching box), so a viewer cannot tell why the search stopped where it did.
level_4: Each box the pointer visits shows a clear compare step (e.g., a small '==4?' label appears as the pointer arrives) before moving on when the values don't match; reaching the box with 4 triggers a distinct green highlight and a 'MATCH!' label, with one minor flaw, such as the comparison label appearing noticeably before or after the pointer actually arrives rather than together with it.
level_5: Every box the pointer visits shows an immediate, legible comparison (e.g., '5≠4', '1≠4', '2≠4', then '4==4') timed to the pointer's arrival; the matching box gets a clear combined signal (a green border, bold '4', and a 'FOUND' label) with no extra revisits or idle pauses; the search visibly stops right after the first match, matching the textbook definition of sequential search.

Spatiotemporal Consistency rubric:
level_1: The pointer jumps instantly between non-adjacent boxes instead of moving through them; boxes flicker in and out of view or change their numeric labels mid-animation; events appear out of order (e.g., the match celebration appears before the pointer ever reaches the box with 4); the array's layout visibly collapses (boxes overlapping, rotated, or randomly resized).
level_2: The pointer's motion is visibly jerky, with sudden speed-ups and slow-downs instead of smooth easing; the boxes noticeably shift position between steps of the search; the numeral font size changes from one box to another; the pointer lingers for clearly uneven, sometimes very long stretches at different boxes, with gaps of more than 0.8 seconds between stops; the horizontal row of boxes looks visibly tilted rather than level, off by more than about 5 degrees from horizontal.
level_3: The pointer moves at a generally steady pace and the boxes stay in place and aligned, but there is one noticeable hiccup: for example a box briefly blinks out of view for an instant, the pointer overshoots a box and visibly snaps back, or a label visibly jitters while the pointer passes it.
level_4: All of the 3-point criteria are met, and the pointer's motion is smooth from box to box with easing only at the very start and end of the traversal; the boxes stay rigidly aligned along a level horizontal row with no visible flicker or label distortion; the pointer spends a visually consistent amount of time at each box and a visibly longer pause on the matched box, with at most one very minor imperfection, such as the pointer's shadow looking slightly offset for a moment.
level_5: All of the 4-point criteria are met, and the pointer's path from one box to the next looks like a clean straight line with no visible drift; there are no rendering glitches, flicker, or stutter anywhere in the animation; every visual change (box highlight, label, pointer, banner) appears to happen together with no visible lag between them; the pointer always stays above the array and the target banner always stays outside the row of boxes; the whole animation reads as a flat, undistorted 2D view with no perspective warping.